Fixed tests

Author: forman

chartlets.js/src/lib/actions/helpers/getInputValues.test.ts

@@ -24,85 +24,48 @@ const componentState = {
 
 describe("Test that getInputValueFromComponent()", () => {
   it("works on 1st level", () => {
-    expect(
-      getInputValueFromComponent(
-        {
-          id: "b1",
-          property: "value",
-        },
-        componentState,
-      ),
-    ).toEqual(14);
+    expect(getInputValueFromComponent(componentState, "b1", "value")).toEqual(
+      14,
+    );
   });
 
   it("works on 2nd level", () => {
-    expect(
-      getInputValueFromComponent(
-        {
-          id: "p1",
-          property: "chart",
-        },
-        componentState,
-      ),
-    ).toEqual(null);
+    expect(getInputValueFromComponent(componentState, "p1", "chart")).toEqual(
+      null,
+    );
   });
 
   it("works on 3rd level", () => {
-    expect(
-      getInputValueFromComponent(
-        {
-          id: "cb1",
-          property: "value",
-        },
-        componentState,
-      ),
-    ).toEqual(true);
-
-    expect(
-      getInputValueFromComponent(
-        {
-          id: "dd1",
-          property: "value",
-        },
-        componentState,
-      ),
-    ).toEqual(13);
-  });
-});
-
-describe("Test that getInputValueFromState()", () => {
-  it("works with input.id and input.property", () => {
-    const state = { x: { y: 26 } };
-    expect(getInputValueFromState({ id: "x", property: "y" }, state)).toEqual(
-      26,
+    expect(getInputValueFromComponent(componentState, "cb1", "value")).toEqual(
+      true,
     );
-  });
 
-  it("works with arrays indexes", () => {
-    const state = { x: [4, 5, 6] };
-    expect(getInputValueFromState({ id: "x", property: "1" }, state)).toEqual(
-      5,
+    expect(getInputValueFromComponent(componentState, "dd1", "value")).toEqual(
+      13,
     );
   });
+});
 
+describe("Test that getInputValueFromState()", () => {
   it("works without input.id", () => {
     const state = { x: [4, 5, 6] };
-    expect(
-      getInputValueFromState({ id: "@container", property: "x" }, state),
-    ).toEqual([4, 5, 6]);
+    expect(getInputValueFromState(state, "x")).toEqual([4, 5, 6]);
   });
 
   it("works on 2nd level", () => {
     const state = { x: { y: 15 } };
-    expect(
-      getInputValueFromState({ id: "@container", property: "x.y" }, state),
-    ).toEqual(15);
+    expect(getInputValueFromState(state, "x.y")).toEqual(15);
   });
 
   it("works on 3nd level", () => {
     const state = { x: { y: [4, 5, 6] } };
+    expect(getInputValueFromState(state, "x.y.2")).toEqual(6);
+  });
+
+  it("works with non-object states", () => {
+    const state = 13;
     expect(
-      getInputValueFromState({ id: "@container", property: "x.y.2" }, state),
-    ).toEqual(6);
+      getInputValueFromState(state as unknown as object, "x.y.2"),
+    ).toBeUndefined();
   });
 });

chartlets.js/src/lib/actions/helpers/getInputValues.ts

@@ -10,7 +10,7 @@ import {
   isComponentState,
   isContainerState,
 } from "@/lib/types/state/component";
-import { formatObjPath, getValue, normalizeObjPath } from "@/lib/utils/objPath";
+import { formatObjPath, getValue, type ObjPathLike } from "@/lib/utils/objPath";
 import { isObject } from "@/lib/utils/isObject";
 import type { HostStore } from "@/lib/types/state/options";
 
@@ -32,12 +32,17 @@ export function getInputValue(
   hostStore?: HostStore,
 ): unknown {
   let inputValue: unknown = undefined;
+  const { id, property } = input;
   if (isComponentChannel(input) && contributionState.component) {
-    inputValue = getInputValueFromComponent(input, contributionState.component);
+    inputValue = getInputValueFromComponent(
+      contributionState.component,
+      id,
+      property,
+    );
   } else if (isContainerChannel(input) && contributionState.container) {
-    inputValue = getInputValueFromState(input, contributionState.container);
+    inputValue = getInputValueFromState(contributionState.container, property);
   } else if (isHostChannel(input) && hostStore) {
-    inputValue = getInputValueFromHostStore(input, hostStore);
+    inputValue = getInputValueFromHostStore(hostStore, property);
   } else {
     console.warn(`input with unknown data source:`, input);
   }
@@ -51,16 +56,17 @@ export function getInputValue(
 
 // we export for testing only
 export function getInputValueFromComponent(
-  input: Input,
   componentState: ComponentState,
+  id: string,
+  property: ObjPathLike,
 ): unknown {
-  if (componentState.id === input.id) {
-    return getValue(componentState, input.property);
+  if (componentState.id === id) {
+    return getValue(componentState, property);
   } else if (isContainerState(componentState)) {
     for (let i = 0; i < componentState.children.length; i++) {
       const item = componentState.children[i];
       if (isComponentState(item)) {
-        const itemValue = getInputValueFromComponent(input, item);
+        const itemValue = getInputValueFromComponent(item, id, property);
         if (itemValue !== noValue) {
           return itemValue;
         }
@@ -72,24 +78,16 @@ export function getInputValueFromComponent(
 
 // we export for testing only
 export function getInputValueFromState(
-  input: Input,
   state: object | undefined,
+  property: ObjPathLike,
 ): unknown {
-  let inputValue: unknown = state;
-  if (input.id && isObject(inputValue)) {
-    inputValue = inputValue[input.id];
-  }
-  if (isObject(inputValue)) {
-    const state = inputValue;
-    const property = normalizeObjPath(input.property);
-    inputValue = getValue(state, property);
-  }
-  return inputValue;
+  return isObject(state) ? getValue(state, property) : undefined;
 }
 
+// we export for testing only
 export function getInputValueFromHostStore(
-  input: Input,
   hostStore: HostStore,
+  property: ObjPathLike,
 ): unknown {
-  return hostStore.get(formatObjPath(input.property));
+  return hostStore.get(formatObjPath(property));
 }