@noya-app/noya-file-explorer 0.0.2

package/src/__tests__/moveUpAFolder.test.ts

@@ -0,0 +1,179 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { moveUpAFolder } from "../utils/files";
+import {
+  createMediaAsset,
+  createMediaFolder,
+  createMediaItemTree,
+} from "../utils/mediaItemTree";
+
+it("should move an item up one level in the folder hierarchy", () => {
+  // Create a folder structure:
+  // Root
+  // └── Folder 1
+  //     └── Folder 2
+  //         └── Asset 1
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    "folder1/folder2": folder2,
+    "folder1/folder2/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Asset 1 up from Folder 2 to Folder 1
+  const result = moveUpAFolder({
+    tree,
+    media: media,
+    selectedIds: [asset1.id],
+  });
+
+  // Asset 1 should now have Folder 1 as its parent
+  expect(result).toBeDefined();
+  expect(result?.["folder1/asset1"]).toEqual(asset1);
+
+  // Other items should remain unchanged
+  expect(result?.["folder1"]).toEqual(folder1);
+  expect(result?.["folder1/folder2"]).toEqual(folder2);
+});
+
+it("should move multiple items up one level at once", () => {
+  // Create a folder structure:
+  // Root
+  // └── Folder 1
+  //     └── Folder 2
+  //         ├── Asset 1
+  //         └── Asset 2
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const asset2 = createMediaAsset({
+    assetId: "asset2",
+  });
+  const media: MediaMap = {
+    folder1,
+    "folder1/folder2": folder2,
+    "folder1/folder2/asset1": asset1,
+    "folder1/folder2/asset2": asset2,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move both assets up from Folder 2 to Folder 1
+  const result = moveUpAFolder({
+    tree,
+    media: media,
+    selectedIds: [asset1.id, asset2.id],
+  });
+
+  // Both assets should now have Folder 1 as their parent
+  expect(result).toBeDefined();
+
+  expect(result?.["folder1/asset1"]).toEqual(asset1);
+  expect(result?.["folder1/asset2"]).toEqual(asset2);
+});
+
+it("should return undefined if the selected item is not found", () => {
+  const folder1 = createMediaFolder();
+
+  const media: MediaMap = {
+    folder1,
+  };
+  const tree = createMediaItemTree(media);
+
+  const result = moveUpAFolder({
+    tree,
+    media: media,
+    selectedIds: ["nonexistent"],
+  });
+
+  expect(result).toBeUndefined();
+});
+
+it("should not move items at root level", () => {
+  // Create a folder structure with only one level:
+  // Root
+  // └── Asset 1
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+
+  const media: MediaMap = {
+    asset1: asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Try to move Asset 1 up, but it's already at the root
+  const result = moveUpAFolder({
+    tree,
+    media: media,
+    selectedIds: [asset1.id],
+  });
+
+  // The function should still return a result, with the asset having undefined parentId
+  expect(result).toBeDefined();
+  expect(result?.["asset1"]).toEqual(asset1);
+});
+
+it("should move items from a subfolder to root if parent is at root level", () => {
+  // Create a folder structure:
+  // Root
+  // └── Folder 1
+  //     └── Asset 1
+  const folder1 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+
+  const media: MediaMap = {
+    folder1,
+    "folder1/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  // Move Asset 1 up from Folder 1 to Root
+  const result = moveUpAFolder({
+    tree,
+    media: media,
+    selectedIds: [asset1.id],
+  });
+
+  expect(result).toBeDefined();
+  expect(result?.["asset1"]).toEqual(asset1);
+});
+
+it("should move a folders descendants up a folder", () => {
+  // Create a folder structure:
+  // Root
+  // └── Folder 1
+  //     └── Folder 2
+  //         └── Asset 1
+  const folder1 = createMediaFolder();
+  const folder2 = createMediaFolder();
+  const asset1 = createMediaAsset({
+    assetId: "asset1",
+  });
+  const media: MediaMap = {
+    folder1,
+    "folder1/folder2": folder2,
+    "folder1/folder2/asset1": asset1,
+  };
+  const tree = createMediaItemTree(media);
+
+  const result = moveUpAFolder({
+    tree,
+    media: media,
+    selectedIds: [folder2.id],
+  });
+
+  expect(result).toBeDefined();
+  expect(result?.["folder2/asset1"]).toEqual(asset1);
+  expect(result?.["folder2"]).toEqual(folder2);
+  expect(result?.["folder1"]).toEqual(folder1);
+  expect(result?.["folder1/folder2"]).toBeUndefined();
+});

package/src/__tests__/updateExpandedMap.test.ts

@@ -0,0 +1,157 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { updateExpandedMap } from "../utils/files";
+import {
+  createMediaFolder,
+  createMediaItemTree,
+  rootMediaItem,
+} from "../utils/mediaItemTree";
+
+it("should expand a folder", () => {
+  const dir1 = createMediaFolder();
+  const media: MediaMap = { dir1 };
+  const tree = createMediaItemTree(media);
+  const expandedMap = {};
+
+  const result = updateExpandedMap({
+    item: dir1,
+    expanded: true,
+    tree,
+    expandable: true,
+    expandedMap,
+  });
+
+  expect(result).toEqual({ [dir1.id]: true });
+});
+
+it("should collapse a folder and all its children", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const media: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+    "dir1/dir3": dir3,
+  };
+  const tree = createMediaItemTree(media);
+  const expandedMap = { [dir1.id]: true, [dir2.id]: true, [dir3.id]: true };
+
+  const result = updateExpandedMap({
+    item: dir1,
+    expanded: false,
+    tree,
+    expandable: true,
+    expandedMap,
+  });
+
+  expect(result).toEqual({
+    [dir1.id]: false,
+    [dir2.id]: false,
+    [dir3.id]: false,
+  });
+});
+
+it("should not modify map if expandable is false", () => {
+  const item = createMediaFolder();
+  const media: MediaMap = { folder: item };
+  const tree = createMediaItemTree(media);
+  const expandedMap = { someOtherId: true };
+
+  const result = updateExpandedMap({
+    item,
+    expanded: true,
+    tree,
+    expandable: false,
+    expandedMap,
+  });
+
+  expect(result).toEqual(expandedMap);
+});
+
+it("should not modify root item expansion state", () => {
+  const media: MediaMap = { rootMediaItem };
+  const tree = createMediaItemTree(media);
+  const expandedMap = { someOtherId: true };
+
+  const result = updateExpandedMap({
+    item: rootMediaItem,
+    expanded: true,
+    tree,
+    expandable: true,
+    expandedMap,
+  });
+
+  expect(result).toEqual(expandedMap);
+});
+
+it("should handle deeply nested folder structure", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const media: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+    "dir1/dir2/dir3": dir3,
+  };
+  const tree = createMediaItemTree(media);
+  const expandedMap = { [dir1.id]: true, [dir2.id]: true, [dir3.id]: true };
+
+  const result = updateExpandedMap({
+    item: dir1,
+    expanded: false,
+    tree,
+    expandable: true,
+    expandedMap,
+  });
+
+  expect(result).toEqual({
+    [dir1.id]: false,
+    [dir2.id]: false,
+    [dir3.id]: false,
+  });
+});
+
+it("should preserve other expanded states when modifying one folder", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const media: MediaMap = { dir1, dir2 };
+  const tree = createMediaItemTree(media);
+  const expandedMap = { [dir1.id]: false, [dir2.id]: true };
+
+  const result = updateExpandedMap({
+    item: dir1,
+    expanded: true,
+    tree,
+    expandable: true,
+    expandedMap,
+  });
+
+  expect(result).toEqual({ [dir1.id]: true, [dir2.id]: true });
+});
+
+it("should handle collapsing with missing children in media array", () => {
+  const dir1 = createMediaFolder();
+  const media: MediaMap = { dir1 };
+  const tree = createMediaItemTree(media);
+  // Expanded map contains children that don't exist in media array
+  const expandedMap = {
+    [dir1.id]: true,
+    missingChild1: true,
+    missingChild2: true,
+  };
+
+  const result = updateExpandedMap({
+    item: dir1,
+    expanded: false,
+    tree,
+    expandable: true,
+    expandedMap,
+  });
+
+  // Should only modify the existing parent's state
+  expect(result).toEqual({
+    [dir1.id]: false,
+    missingChild1: true,
+    missingChild2: true,
+  });
+});

package/src/__tests__/validateMediaItemRename.test.ts

@@ -0,0 +1,200 @@
+import { MediaMap } from "@noya-app/noya-schemas";
+import { expect, it } from "bun:test";
+import { validateMediaItemRename } from "../utils/files";
+import { createMediaAsset, createMediaFolder } from "../utils/mediaItemTree";
+
+it("should return true for valid rename with no conflicts", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1.jpg": file1,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "newname.jpg",
+    selectedItemPath: "dir1/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(true);
+});
+
+it("should return false when a file with the same name already exists", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const file2 = createMediaAsset({ assetId: "2" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1.jpg": file1,
+    "dir1/file2.jpg": file2,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "file2.jpg",
+    selectedItemPath: "dir1/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(false);
+});
+
+it("should return false when renaming a file to its own name", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1.jpg": file1,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "file1.jpg",
+    selectedItemPath: "dir1/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(false);
+});
+
+it("should return true when renaming a folder with no conflicts", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "newdir",
+    selectedItemPath: "dir1/dir2",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(true);
+});
+
+it("should return false when a folder with the same name already exists", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+    "dir1/dir3": dir3,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "dir3",
+    selectedItemPath: "dir1/dir2",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(false);
+});
+
+it("should handle special characters in basename", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1.jpg": file1,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "new-file@name.jpg",
+    selectedItemPath: "dir1/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(true);
+});
+
+it("should return true when renaming to a name that exists in a different directory", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const file2 = createMediaAsset({ assetId: "2" });
+  const mediaMap: MediaMap = {
+    dir1,
+    dir2,
+    "dir1/file1.jpg": file1,
+    "dir2/file2.jpg": file2,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "file2.jpg",
+    selectedItemPath: "dir1/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(true);
+});
+
+it("should return false when trying to rename to an empty basename", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1.jpg": file1,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "",
+    selectedItemPath: "dir1/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(false);
+});
+
+it("should handle deep nested directories", () => {
+  const dir1 = createMediaFolder();
+  const dir2 = createMediaFolder();
+  const dir3 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/dir2": dir2,
+    "dir1/dir2/dir3": dir3,
+    "dir1/dir2/dir3/file1.jpg": file1,
+  };
+
+  const result = validateMediaItemRename({
+    basename: "renamed.jpg",
+    selectedItemPath: "dir1/dir2/dir3/file1.jpg",
+    media: mediaMap,
+  });
+
+  expect(result).toBe(true);
+});
+
+it("should return false when basename contains invalid filesystem characters", () => {
+  const dir1 = createMediaFolder();
+  const file1 = createMediaAsset({ assetId: "1" });
+  const mediaMap: MediaMap = {
+    dir1,
+    "dir1/file1.jpg": file1,
+  };
+
+  const invalidNames = [
+    "file/name.jpg",
+    "file\\name.jpg",
+    "file<name.jpg",
+    "file>name.jpg",
+    'file"name.jpg',
+    "file:name.jpg",
+    "file|name.jpg",
+    "file?name.jpg",
+    "file*name.jpg",
+  ];
+
+  invalidNames.forEach((basename) => {
+    const result = validateMediaItemRename({
+      basename,
+      selectedItemPath: "dir1/file1.jpg",
+      media: mediaMap,
+    });
+
+    expect(result).toBe(false);
+  });
+});

package/src/index.css

@@ -0,0 +1 @@
+@import "@noya-app/noya-designsystem/index.css";

package/src/index.ts

@@ -0,0 +1,4 @@
+import "./index.css";
+export * from "./MediaCollection";
+export * from "./utils/files";
+export * from "./utils/mediaItemTree";