@headless-tree/core 0.0.10 → 0.0.12

package/src/utilities/insert-items-at-target.ts

@@ -8,11 +8,15 @@ export const insertItemsAtTarget = <T>(
 ) => {
   // add moved items to new common parent, if dropped onto parent
   if (target.childIndex === null) {
-    onChangeChildren(target.item, [
+    const newChildren = [
       ...target.item.getChildren().map((item) => item.getId()),
       ...itemIds,
-    ]);
-    // TODO items[0].getTree().rebuildTree();
+    ];
+    onChangeChildren(target.item, newChildren);
+    if (target.item && "updateCachedChildrenIds" in target.item) {
+      target.item.updateCachedChildrenIds(newChildren);
+    }
+    target.item.getTree().rebuildTree();
     return;
   }
 
@@ -26,5 +30,8 @@ export const insertItemsAtTarget = <T>(
 
   onChangeChildren(target.item, newChildren);
 
+  if (target.item && "updateCachedChildrenIds" in target.item) {
+    target.item.updateCachedChildrenIds(newChildren);
+  }
   target.item.getTree().rebuildTree();
 };

package/src/utilities/remove-items-from-parents.ts

@@ -4,16 +4,21 @@ export const removeItemsFromParents = <T>(
   movedItems: ItemInstance<T>[],
   onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void,
 ) => {
-  // TODO bulk sibling changes together
-  for (const item of movedItems) {
-    const siblings = item.getParent()?.getChildren();
-    if (siblings) {
-      onChangeChildren(
-        item.getParent(),
-        siblings
-          .filter((sibling) => sibling.getId() !== item.getId())
-          .map((i) => i.getId()),
-      );
+  const movedItemsIds = movedItems.map((item) => item.getId());
+  const uniqueParents = [
+    ...new Set(movedItems.map((item) => item.getParent())),
+  ];
+
+  for (const parent of uniqueParents) {
+    const siblings = parent?.getChildren();
+    if (siblings && parent) {
+      const newChildren = siblings
+        .filter((sibling) => !movedItemsIds.includes(sibling.getId()))
+        .map((i) => i.getId());
+      onChangeChildren(parent, newChildren);
+      if (parent && "updateCachedChildrenIds" in parent) {
+        parent?.updateCachedChildrenIds(newChildren);
+      }
     }
   }
 

package/src/utils.spec.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from "vitest";
+import { makeStateUpdater, memo, poll } from "./utils";
+
+vi.useFakeTimers({ shouldAdvanceTime: true });
+
+describe("utilities", () => {
+  describe("memo", () => {
+    it("returns same value for same arguments", () => {
+      const fn = vi.fn(
+        (a: number, b: number, c: number, d: number) => a + b + c + d,
+      );
+      const memoized = memo((c: number, d: number) => [1, 1, c, d], fn);
+      expect(memoized(1, 1)).toBe(4);
+      expect(memoized(1, 1)).toBe(4);
+      expect(memoized(1, 1)).toBe(4);
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it("returns different values for different arguments", () => {
+      const fn = vi.fn(
+        (a: number, b: number, c: number, d: number) => a + b + c + d,
+      );
+      const memoized = memo((c: number, d: number) => [1, 1, c, d], fn);
+      expect(memoized(1, 1)).toBe(4);
+      expect(memoized(1, 2)).toBe(5);
+      expect(memoized(1, 2)).toBe(5);
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("makeStateUpdater", () => {
+    it("updates the state correctly", () => {
+      const instance = {
+        setState: vi.fn((updater) => {
+          const oldState = { focusedItem: "oldValue" };
+          const newState = updater(oldState);
+          return newState;
+        }),
+      };
+
+      const updater = makeStateUpdater("focusedItem", instance);
+      updater("newValue");
+
+      expect(instance.setState).toHaveBeenCalledTimes(1);
+      expect(instance.setState).toHaveBeenCalledWith(expect.any(Function));
+      const stateUpdateFn = instance.setState.mock.calls[0][0];
+      expect(stateUpdateFn({ focusedItem: "oldValue" })).toEqual({
+        focusedItem: "newValue",
+      });
+    });
+
+    it("updates the state using a function updater", () => {
+      const instance = {
+        setState: vi.fn((updater) => {
+          const oldState = { focusedItem: "oldValue" };
+          const newState = updater(oldState);
+          return newState;
+        }),
+      };
+
+      const updater = makeStateUpdater("focusedItem", instance);
+      updater((prev) => `${prev}Updated`);
+
+      expect(instance.setState).toHaveBeenCalledTimes(1);
+      expect(instance.setState).toHaveBeenCalledWith(expect.any(Function));
+      const stateUpdateFn = instance.setState.mock.calls[0][0];
+      expect(stateUpdateFn({ focusedItem: "oldValue" })).toEqual({
+        focusedItem: "oldValueUpdated",
+      });
+    });
+  });
+
+  describe("poll", () => {
+    it("resolves when the condition is met within the timeout", async () => {
+      const condition = vi
+        .fn()
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(true);
+      await expect(poll(condition, 50, 200)).resolves.toBeUndefined();
+      expect(condition).toHaveBeenCalledTimes(2);
+    });
+
+    it("resolves immediately if the condition is already met", async () => {
+      const condition = vi.fn().mockReturnValue(true);
+      await expect(poll(condition, 50, 200)).resolves.toBeUndefined();
+      expect(condition).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/utils.ts

@@ -1,16 +1,16 @@
-import { TreeState, Updater } from "./types/core";
+import { SetStateFn, TreeState, Updater } from "./types/core";
 
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 
-export const memo = <D extends readonly any[], R>(
+export const memo = <D extends readonly any[], P extends readonly any[], R>(
+  deps: (...args: [...P]) => [...D],
   fn: (...args: [...D]) => R,
-  deps: () => [...D],
 ) => {
   let value: R | undefined;
   let oldDeps: D | null = null;
 
-  return () => {
-    const newDeps = deps();
+  return (...a: [...P]) => {
+    const newDeps = deps(...a);
 
     if (!value) {
       value = fn(...newDeps);
@@ -41,7 +41,7 @@ export function functionalUpdate<T>(updater: Updater<T>, input: T): T {
 export function makeStateUpdater<K extends keyof TreeState<any>>(
   key: K,
   instance: unknown,
-) {
+): SetStateFn<TreeState<any>[K]> {
   return (updater: Updater<TreeState<any>[K]>) => {
     (instance as any).setState(<TTableState>(old: TTableState) => {
       return {

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "include": ["./src/**/*"],
+  "exclude": ["./src/**/*.spec.tsx", "./src/**/*.spec.ts", "./src/**/*.stories.tsx"],
   "compilerOptions": {
     "outDir": "lib/esm"
   }

package/vitest.config.ts

@@ -0,0 +1,6 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {},
+});