@noya-app/noya-file-explorer 0.0.2

package/src/__tests__/deleteMediaItems.test.ts

@@ -0,0 +1,125 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { deleteMediaItems } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  createMediaItemTree,
+} from "../utils/mediaItemTree";
+it("should delete a folder with no children", () => {
+  const dir1 = createMediaFolder();
+  const media: MediaMap = { dir1 };
+
+  const tree = createMediaItemTree(media);
+
+  const result = deleteMediaItems({
+    selectedIds: [dir1.id],
+    media,
+    tree,
+  });
+
+  expect(result).toEqual({});
+});
+
+it("should delete a folder and its immediate children", () => {
+  const dir1 = createMediaFolder();
+  const child1 = createMediaAsset({ assetId: "asset1" });
+  const child2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const media: MediaMap = {
+    dir1,
+    "dir1/child1": child1,
+    "dir1/child2": child2,
+    dir3,
+  };
+  const tree = createMediaItemTree(media);
+
+  const result = deleteMediaItems({
+    selectedIds: [dir1.id],
+    media,
+    tree,
+  });
+
+  expect(result).toEqual({ dir3 });
+});
+
+it("should delete a folder and all nested descendants", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const asset1 = createMediaAsset({ assetId: "asset1" });
+  const dir4 = createMediaFolder();
+  const media: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+    "dir1/dir2/dir3": dir3,
+    "dir1/dir2/dir3/asset1": asset1,
+    dir4,
+  };
+  const tree = createMediaItemTree(media);
+  const result = deleteMediaItems({
+    selectedIds: [dir1.id],
+    media,
+    tree,
+  });
+
+  expect(result).toEqual({ dir4 });
+});
+
+it("should handle deleting folder with mixed content types", () => {
+  const dir1 = createMediaFolder();
+  const asset1 = createMediaAsset({ assetId: "asset1" });
+  const dir2 = createMediaFolder();
+  const asset2 = createMediaAsset({ assetId: "asset2" });
+  const asset3 = createMediaAsset({ assetId: "asset3" });
+  const media: MediaMap = {
+    dir1,
+    "dir1/asset1": asset1,
+    "dir1/dir2": dir2,
+    "dir1/dir2/asset2": asset2,
+    asset3,
+  };
+  const tree = createMediaItemTree(media);
+  const result = deleteMediaItems({
+    selectedIds: [dir1.id],
+    media,
+    tree,
+  });
+
+  expect(result).toEqual({ asset3 });
+});
+
+it("should handle attempting to delete non-existent folder", () => {
+  const dir1 = createMediaFolder();
+  const asset1 = createMediaAsset({ assetId: "asset1" });
+  const media: MediaMap = { dir1, asset1 };
+  const tree = createMediaItemTree(media);
+  const result = deleteMediaItems({
+    selectedIds: ["non-existent"],
+    media,
+    tree,
+  });
+
+  expect(result).toEqual(media);
+});
+
+it("should preserve sibling directories and their contents", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const asset1 = createMediaAsset({ assetId: "asset1" });
+  const asset2 = createMediaAsset({ assetId: "asset2" });
+  const media: MediaMap = {
+    dir1,
+    dir2,
+    "dir1/asset1": asset1,
+    "dir2/asset2": asset2,
+  };
+  const tree = createMediaItemTree(media);
+  const result = deleteMediaItems({
+    selectedIds: [dir1.id],
+    media,
+    tree,
+  });
+
+  expect(result).toEqual({ dir2, "dir2/asset2": asset2 });
+});

package/src/__tests__/getDepthMap.test.ts

@@ -0,0 +1,84 @@
+import { expect, it } from "bun:test";
+import { getDepthMap } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  createMediaItemTree,
+  rootMediaItem,
+} from "../utils/mediaItemTree";
+
+it("should return empty map for empty tree", () => {
+  const tree = createMediaItemTree({});
+  const result = getDepthMap(rootMediaItem, tree, true);
+  expect(result).toEqual({ [rootMediaItem.id]: 0 });
+});
+
+it("should set depth 0 for root level items", () => {
+  const asset1 = createMediaAsset({ assetId: "1" });
+  const asset2 = createMediaAsset({ assetId: "2" });
+  const tree = createMediaItemTree({ asset1, asset2 });
+  const result = getDepthMap(rootMediaItem, tree, true);
+  expect(result[asset1.id]).toBe(0);
+  expect(result[asset2.id]).toBe(0);
+});
+
+it("should calculate correct depths for nested items", () => {
+  const parent = createMediaFolder();
+  const child = createMediaAsset({
+    assetId: "1",
+  });
+  const grandChild = createMediaAsset({ assetId: "2" });
+  const tree = createMediaItemTree({
+    parent,
+    "parent/child": child,
+    "parent/child/grandChild": grandChild,
+  });
+  const result = getDepthMap(rootMediaItem, tree, true);
+  expect(result[parent.id]).toBe(0);
+  expect(result[child.id]).toBe(1);
+  expect(result[grandChild.id]).toBe(2);
+});
+
+it("should handle multiple branches with different depths", () => {
+  const parent1 = createMediaFolder();
+  const parent2 = createMediaFolder();
+  const child1 = createMediaAsset({ assetId: "1" });
+  const child2 = createMediaAsset({ assetId: "2" });
+  const grandChild = createMediaAsset({ assetId: "3" });
+  const tree = createMediaItemTree({
+    parent1,
+    parent2,
+    "parent1/child1": child1,
+    "parent2/child2": child2,
+    "parent1/child1/grandChild": grandChild,
+  });
+  const result = getDepthMap(rootMediaItem, tree, true);
+  expect(result[parent1.id]).toBe(0);
+  expect(result[parent2.id]).toBe(0);
+  expect(result[child1.id]).toBe(1);
+  expect(result[child2.id]).toBe(1);
+  expect(result[grandChild.id]).toBe(2);
+});
+
+it("should handle orphaned items", () => {
+  const asset1 = createMediaAsset({ assetId: "1" });
+  const asset2 = createMediaAsset({ assetId: "2" });
+  const tree = createMediaItemTree({
+    "non-existent": asset1,
+    asset2,
+  });
+  const result = getDepthMap(rootMediaItem, tree, true);
+  expect(result[rootMediaItem.id]).toBe(0);
+  expect(result[asset2.id]).toBe(0);
+  expect(result[asset1.id]).toBe(0);
+});
+
+it("should set all depths to 0 when showAllDescendants is false", () => {
+  const dir = createMediaFolder();
+  const asset = createMediaAsset({ assetId: "1" });
+  const tree = createMediaItemTree({ dir, "dir/asset": asset });
+  const result = getDepthMap(rootMediaItem, tree, false);
+  expect(result[rootMediaItem.id]).toBe(0);
+  expect(result[dir.id]).toBe(0);
+  expect(result[asset.id]).toBe(0);
+});

package/src/__tests__/getParentDirectories.test.ts

@@ -0,0 +1,68 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { getParentDirectories } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  rootMediaItem,
+} from "../utils/mediaItemTree";
+
+it("should return root for non-existent directory", () => {
+  const dir1 = createMediaFolder();
+  const mediaMap: MediaMap = {
+    dir1: dir1,
+  };
+
+  const result = getParentDirectories(mediaMap, "non-existent");
+  expect(result).toEqual([rootMediaItem]);
+});
+
+it("should return root and directory item for root-level directory", () => {
+  const dir1 = createMediaFolder();
+  const mediaMap: MediaMap = {
+    dir1,
+  };
+
+  const result = getParentDirectories(mediaMap, dir1.id);
+  expect(result).toEqual([rootMediaItem, dir1]);
+});
+
+it("should return path for nested directory", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+    "dir1/dir2/dir3": dir3,
+  };
+
+  const result = getParentDirectories(mediaMap, dir3.id);
+  expect(result).toEqual([rootMediaItem, dir1, dir2, dir3]);
+});
+
+it("should handle missing parent by returning root", () => {
+  const asset1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    "dir3/asset1": asset1,
+  };
+
+  const result = getParentDirectories(mediaMap, asset1.id);
+  expect(result).toEqual([rootMediaItem]);
+});
+
+it("should work with mixed file types in media array", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const dir2 = createMediaFolder();
+  const file2 = createMediaAsset({ assetId: "2" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1": file1,
+    "dir1/dir2": dir2,
+    "dir1/dir2/file2": file2,
+  };
+
+  const result = getParentDirectories(mediaMap, dir2.id);
+  expect(result).toEqual([rootMediaItem, dir1, dir2]);
+});

package/src/__tests__/getVisibleItems.test.ts

@@ -0,0 +1,184 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { getVisibleItems } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  createMediaItemTree,
+  rootMediaItem,
+} from "../utils/mediaItemTree";
+
+it("should return all items if no filter is applied", () => {
+  const item1 = createMediaAsset({ assetId: "1" });
+  const item2 = createMediaAsset({ assetId: "2" });
+  const media: MediaMap = { item1, item2 };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    expandedMap: {},
+    fileKindFilter: "assets",
+    rootItemId: rootMediaItem.id,
+    tree,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([item1, item2]);
+});
+
+it("should filter by file type - files only", () => {
+  const asset1 = createMediaAsset({ assetId: "1" });
+  const folder = createMediaFolder();
+  const asset2 = createMediaAsset({ assetId: "2" });
+  const media: MediaMap = { asset1, folder, asset2 };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: {},
+    fileKindFilter: "assets",
+    rootItemId: rootMediaItem.id,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([asset1, asset2]);
+});
+
+it("should filter by file type - directories only", () => {
+  const asset1 = createMediaAsset({ assetId: "1" });
+  const folder = createMediaFolder();
+  const asset2 = createMediaAsset({ assetId: "2" });
+  const media: MediaMap = { asset1, folder, asset2 };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: {},
+    fileKindFilter: "directories",
+    rootItemId: rootMediaItem.id,
+    showAllDescendants: true,
+    showRootItem: true,
+  });
+  expect(result).toEqual([rootMediaItem, folder]);
+});
+
+it("should filter by parent ID", () => {
+  const parent = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "1",
+  });
+  const asset2 = createMediaAsset({
+    assetId: "2",
+  });
+  const media: MediaMap = { parent, asset1, "parent/asset2": asset2 };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: {},
+    fileKindFilter: "all",
+    rootItemId: parent.id,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([asset2]);
+});
+
+it("should show root level items when filtering by root ID", () => {
+  const asset1 = createMediaAsset({ assetId: "1" });
+  const asset2 = createMediaAsset({
+    assetId: "2",
+  });
+  const asset3 = createMediaAsset({ assetId: "3" });
+  const media: MediaMap = { asset1, "does not exist/asset2": asset2, asset3 };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: {},
+    fileKindFilter: "all",
+    rootItemId: rootMediaItem.id,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([asset1, asset3]);
+});
+
+it("should show items based on expanded state", () => {
+  const dir1 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "1",
+  });
+  const dir2 = createMediaFolder();
+  const asset2 = createMediaAsset({
+    assetId: "2",
+  });
+  const media: MediaMap = {
+    dir1,
+    "dir1/asset1": asset1,
+    dir2,
+    "dir2/asset2": asset2,
+  };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: { [dir1.id]: true, [dir2.id]: false },
+    fileKindFilter: "all",
+    rootItemId: rootMediaItem.id,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([dir1, asset1, dir2]);
+});
+
+it("should combine file type and parent ID filters", () => {
+  const parent1 = createMediaFolder();
+  const file1 = createMediaAsset({
+    assetId: "1",
+  });
+  const file2 = createMediaAsset({ assetId: "2" });
+  const parent2 = createMediaFolder();
+  const media: MediaMap = {
+    parent1,
+    "parent1/file1": file1,
+    file2,
+    "parent1/parent2": parent2,
+  };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: {},
+    fileKindFilter: "assets",
+    rootItemId: parent1.id,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([file1]);
+});
+it("should hide items in parent directories that are not expanded", () => {
+  const parent1 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "1",
+  });
+  const asset2 = createMediaAsset({
+    assetId: "2",
+  });
+  const parent2 = createMediaFolder();
+  const asset3 = createMediaAsset({
+    assetId: "3",
+  });
+  const media: MediaMap = {
+    parent1,
+    "parent1/asset1": asset1,
+    "parent1/asset2": asset2,
+    "parent1/parent2": parent2,
+    "parent1/parent2/asset3": asset3,
+  };
+  const tree = createMediaItemTree(media);
+  const result = getVisibleItems({
+    tree,
+    expandedMap: {
+      [parent1.id]: true,
+      [parent2.id]: undefined,
+    },
+    fileKindFilter: "all",
+    rootItemId: rootMediaItem.id,
+    showAllDescendants: true,
+    showRootItem: false,
+  });
+  expect(result).toEqual([parent1, asset1, asset2, parent2]);
+});