renamed getValue.ts into objPath.ts: first impl. of setValue()

Author: forman

dashi/src/lib/actions/handleHostStoreChange.ts

@@ -9,7 +9,7 @@ import type {
 } from "@/lib/types/model/callback";
 import type { Input } from "@/lib/types/model/channel";
 import { getInputValues } from "@/lib/actions/helpers/getInputValues";
-import { getValue, type PropertyPath } from "@/lib/utils/getValue";
+import { getValue, type ObjPath } from "@/lib/utils/objPath";
 import { invokeCallbacks } from "@/lib/actions/helpers/invokeCallbacks";
 import type { ContributionState } from "@/lib";
 
@@ -18,7 +18,7 @@ import type { ContributionState } from "@/lib";
  */
 export interface PropertyRef extends ContribRef, CallbackRef, InputRef {
   /** The property name as path. */
-  propertyPath: PropertyPath;
+  propertyPath: ObjPath;
 }
 
 export function handleHostStoreChange<S extends object = object>(
@@ -89,11 +89,11 @@ function _getHostStorePropertyRefs(): PropertyRef[] {
 }
 
 function hasPropertyChanged<S extends object = object>(
-  propertyPath: PropertyPath,
+  propertyPath: ObjPath,
   currState: S,
   prevState: S,
 ): boolean {
-  const currValue = getValue(currState, propertyPath);
-  const prevValue = getValue(prevState, propertyPath);
+  const currValue = propertyPath(currState, propertyPath);
+  const prevValue = propertyPath(prevState, propertyPath);
   return !Object.is(currValue, prevValue);
 }

dashi/src/lib/actions/helpers/getInputValues.ts

@@ -3,7 +3,7 @@ import type { ContributionState } from "@/lib/types/state/contribution";
 import type { ComponentState } from "@/lib/types/state/component";
 import { isSubscriptable } from "@/lib/utils/isSubscriptable";
 import { isContainerState } from "@/lib/actions/helpers/isContainerState";
-import { getValue } from "@/lib/utils/getValue";
+import { getValue } from "@/lib/utils/objPath";
 
 export function getInputValues<S extends object = object>(
   inputs: Input[],

dashi/src/lib/utils/getValue.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+
+import { getValue, setValue } from "./objPath";
+
+describe("Test that getValue()", () => {
+  it("works on 0th level", () => {
+    const obj = { a: 1, b: "x" };
+    expect(getValue(obj, [])).toEqual({ a: 1, b: "x" });
+  });
+
+  it("works on 1st level", () => {
+    const obj = { a: 1, b: "x" };
+    expect(getValue(obj, ["a"])).toEqual(1);
+    expect(getValue(obj, ["b"])).toEqual("x");
+  });
+
+  it("works on 2nd level", () => {
+    const obj = { a: [1, 2, 3], b: { c: "x" } };
+    expect(getValue(obj, ["a", "1"])).toEqual(2);
+    expect(getValue(obj, ["a", 2])).toEqual(3);
+    expect(getValue(obj, ["b", "c"])).toEqual("x");
+  });
+});
+
+describe("Test that setValue()", () => {
+  it("works on 0th level", () => {
+    const obj = { a: 1, b: "x" };
+    const obj2 = setValue(obj, [], 13);
+    expect(obj2).toBe(obj);
+  });
+
+  it("works on 1st level object - change", () => {
+    const obj = { a: 1, b: "x" };
+    const obj2 = setValue(obj, ["a"], 2);
+    expect(obj2).not.toBe(obj);
+    expect(obj2).toEqual({ a: 2, b: "x" });
+  });
+
+  it("works on 1st level object - create", () => {
+    const obj = { b: "x" };
+    const obj2 = setValue(obj, ["a"], 11);
+    expect(obj2).not.toBe(obj);
+    expect(obj2).toEqual({ a: 11, b: "x" });
+  });
+
+  it("works on 1st level object - no change", () => {
+    const obj = { a: 1, b: "x" };
+    const obj2 = setValue(obj, ["a"], 1);
+    expect(obj2).toBe(obj);
+    expect(obj2).toEqual({ a: 1, b: "x" });
+  });
+
+  it("works on 1st level array - change", () => {
+    const obj = { a: [1, 2, 3], b: "x" };
+    const obj2 = setValue(obj, ["a", 2], 15);
+    expect(obj2).not.toBe(obj);
+    expect(obj2).toEqual({ a: [1, 2, 15], b: "x" });
+  });
+
+  it("works on 1st level array - create", () => {
+    const obj = { b: "x" };
+    const obj2 = setValue(obj, ["a", 0], 14);
+    expect(obj2).not.toBe(obj);
+    expect(obj2).toEqual({ a: [14], b: "x" });
+  });
+
+  it("works on 1st level array - no change", () => {
+    const obj = { a: [1, 2, 3], b: "x" };
+    const obj2 = setValue(obj, ["a", 1], 2);
+    expect(obj2).toBe(obj);
+    expect(obj2).toEqual({ a: [1, 2, 3], b: "x" });
+  });
+});

dashi/src/lib/utils/getValue.ts

@@ -0,0 +1,80 @@
+export type ObjPath = (string | number)[];
+
+export function getValue(obj: object, path: ObjPath): unknown {
+  let value: unknown = obj;
+  for (const key of path) {
+    if (typeof value === "object") {
+      value = (value as unknown as Record<string, unknown>)[key];
+    } else {
+      return undefined;
+    }
+  }
+  return value;
+}
+
+export function setValue<S extends object>(
+  obj: S,
+  path: ObjPath | string,
+  value: unknown,
+): S | undefined {
+  return _setValue(obj, toObjPath(path), value);
+}
+
+export function _setValue<S extends object>(
+  obj: S,
+  path: ObjPath,
+  value: unknown,
+): S | undefined {
+  if (path.length === 1) {
+    const key = path[0];
+    if (typeof obj === "object") {
+      const oldValue = obj[key];
+      if (value === oldValue) {
+        return obj;
+      }
+      const newObj = Array.isArray(obj)
+        ? ([...obj] as unknown[])
+        : ({ ...obj } as Record<string, unknown>);
+      newObj[key] = value;
+      return newObj as S;
+    } else if (obj === undefined) {
+      const newObj =
+        typeof key === "number"
+          ? ([] as unknown[])
+          : ({} as Record<string, unknown>);
+      newObj[key] = value;
+      return newObj as S;
+    }
+  } else if (path.length > 1) {
+    if (typeof obj === "object") {
+      const key = path[0];
+      const subObj = obj[key];
+      const newSubObj = setValue(subObj, path.slice(1), value);
+      if (subObj !== newSubObj) {
+        const newObj = Array.isArray(obj)
+          ? ([...obj] as unknown[])
+          : ({ ...obj } as Record<string, unknown>);
+        newObj[key] = newSubObj;
+        return newObj as S;
+      }
+    }
+  }
+  return obj;
+}
+
+function toObjPath(property: ObjPath | string): ObjPath {
+  if (Array.isArray(property)) {
+    return property as ObjPath;
+  }
+  if (property === "") {
+    return [];
+  }
+  const objPath: ObjPath = property.split(".");
+  for (let i = 0; i < objPath.length; i++) {
+    const index = Number(objPath[i]);
+    if (Number.isInteger(index)) {
+      objPath[i] = index;
+    }
+  }
+  return objPath;
+}