@noya-app/noya-file-explorer 0.0.15 → 0.0.17

package/src/utils/resourceUtils.ts

@@ -0,0 +1,329 @@
+import {
+  createResourceTree,
+  Resource,
+  ResourceMap,
+  ResourceTree,
+  rootResource,
+} from "@noya-app/noya-schemas";
+import { path } from "imfs";
+import { ancestorPaths } from "tree-visit";
+
+export type FileKindFilter = "assets" | "directories" | "resources" | "all";
+export type ExpandedMap = Record<string, boolean | undefined>;
+
+export type GetVisibleItemsOptions = {
+  expandedMap: ExpandedMap;
+  fileKindFilter: FileKindFilter;
+  rootItemId: string;
+  tree: ResourceTree;
+  showAllDescendants: boolean;
+  showRootItem: boolean;
+};
+
+export const getVisibleItems = ({
+  expandedMap,
+  fileKindFilter,
+  rootItemId,
+  tree,
+  showAllDescendants,
+  showRootItem,
+}: GetVisibleItemsOptions) => {
+  const filteredItems: Resource[] = [];
+  const relativeRootItem =
+    tree.find(rootResource, (item) => item.id === rootItemId) ?? rootResource;
+
+  tree.visit(relativeRootItem, (item) => {
+    if (relativeRootItem.id === item.id) {
+      if (showRootItem) {
+        filteredItems.push(item);
+      }
+      return;
+    }
+    if (item.type === "file" && fileKindFilter === "all") {
+      filteredItems.push(item);
+    }
+    if (
+      item.type === "asset" &&
+      (fileKindFilter === "assets" || fileKindFilter === "all")
+    ) {
+      filteredItems.push(item);
+    }
+    if (
+      item.type === "directory" &&
+      (fileKindFilter === "directories" || fileKindFilter === "all")
+    ) {
+      filteredItems.push(item);
+    }
+    if (
+      item.type === "resource" &&
+      (fileKindFilter === "resources" || fileKindFilter === "all")
+    ) {
+      filteredItems.push(item);
+    }
+    if (!expandedMap[item.id] || !showAllDescendants) return "skip";
+  });
+  return filteredItems;
+};
+
+/**
+ * Validates if a basename follows typical file naming conventions
+ * Disallows:
+ * - Path separators (/ and \)
+ * - Characters typically invalid in filesystems (<, >, :, ", |, ?, *)
+ * - Empty names
+ */
+export const basenameValidator = (basename: string): boolean => {
+  // Check for empty string
+  if (!basename || basename.trim() === "") return false;
+
+  // Simple regex matching common invalid filesystem characters
+  const invalidCharsRegex = /[/\\<>:"|?*]/;
+  return !invalidCharsRegex.test(basename);
+};
+
+export const validateResourceRename = ({
+  basename,
+  selectedItemPath,
+  media,
+}: {
+  basename: string;
+  selectedItemPath: string;
+  media: ResourceMap;
+}): boolean => {
+  if (!basenameValidator(basename)) return false;
+  const newItemPath = path.join(path.dirname(selectedItemPath), basename);
+  // traverse the tree and check if there is already a path with the new name
+  const newPathExists = media[newItemPath];
+  if (newPathExists) return false;
+  return true;
+};
+
+export const movePathsIntoTarget = ({
+  media,
+  sourceItemPaths,
+  targetItemPath,
+  tree,
+}: {
+  media: ResourceMap;
+  sourceItemPaths: string[];
+  targetItemPath: string;
+  tree: ResourceTree;
+}) => {
+  const ancestors = ancestorPaths(
+    sourceItemPaths.map((path) => path.split("/"))
+  );
+  const mediaClone = { ...media };
+  for (const ancestor of ancestors) {
+    const ancestorPath = ancestor.join("/");
+    const ancestorItem = mediaClone[ancestorPath];
+    const newAncestorPath = path.join(
+      targetItemPath,
+      path.basename(ancestorPath)
+    );
+    if (!ancestorItem) continue;
+    const descendantPaths = tree
+      .flat(ancestorItem)
+      .map((item) => tree.idToPathMap.get(item.id));
+    for (const descendantPath of descendantPaths) {
+      if (!descendantPath) continue;
+      const newDescendantPath = descendantPath.replace(
+        ancestorPath,
+        newAncestorPath
+      );
+      const newPathIsValid = validateResourceRename({
+        basename: path.basename(descendantPath),
+        selectedItemPath: newDescendantPath,
+        media,
+      });
+      if (newPathIsValid) {
+        mediaClone[newDescendantPath] = mediaClone[descendantPath];
+        delete mediaClone[descendantPath];
+      }
+    }
+  }
+  return mediaClone;
+};
+
+export const moveUpAFolder = ({
+  tree,
+  media,
+  selectedIds,
+}: {
+  tree: ResourceTree;
+  media: ResourceMap;
+  selectedIds: string[];
+}) => {
+  const indexPath = tree.findPath(
+    rootResource,
+    (item) => item.id === selectedIds[0]
+  );
+  if (!indexPath) return;
+
+  // Get the grandparent folder (where items will be moved to)
+  const grandparentFolder = tree.access(
+    rootResource,
+    indexPath.slice(0, indexPath.length - 2)
+  );
+  const grandparentFolderPath = tree.idToPathMap.get(grandparentFolder.id);
+  if (!grandparentFolderPath) return;
+
+  const sourceItemPaths = selectedIds
+    .map((id) => tree.idToPathMap.get(id))
+    .filter((path): path is string => Boolean(path));
+  return movePathsIntoTarget({
+    media,
+    targetItemPath: grandparentFolderPath,
+    sourceItemPaths,
+    tree,
+  });
+};
+
+export const getDepthMap = (
+  item: Resource,
+  tree: ResourceTree,
+  showAllDescendants: boolean
+): Record<string, number> => {
+  const depthMap: Record<string, number> = {};
+  tree.visit(item, (item, indexPath) => {
+    if (showAllDescendants) {
+      depthMap[item.id] = Math.max(indexPath.length - 1, 0);
+    } else {
+      depthMap[item.id] = 0;
+    }
+  });
+  return depthMap;
+};
+
+export const updateExpandedMap = ({
+  item,
+  expanded,
+  expandable,
+  expandedMap,
+  tree,
+}: {
+  item: Resource;
+  expanded: boolean;
+  expandable: boolean;
+  expandedMap: ExpandedMap;
+  tree: ResourceTree;
+}): ExpandedMap => {
+  const newExpandedMap = { ...expandedMap };
+  const inner = (item: Resource, expanded: boolean) => {
+    if (!expandable) return {};
+    // Don't allow toggling the fake root
+    if (item.id === rootResource.id) return {};
+    if (!expanded) {
+      // recursively collapse all children
+      const children = tree.getChildren(item, []);
+      children.forEach((child) => inner(child, false));
+    }
+    newExpandedMap[item.id] = expanded;
+  };
+  inner(item, expanded);
+  return newExpandedMap;
+};
+
+export const deleteResources = ({
+  selectedIds,
+  media,
+  tree,
+}: {
+  selectedIds: string[];
+  media: ResourceMap;
+  tree: ResourceTree;
+}): ResourceMap => {
+  const itemsToDelete = selectedIds.flatMap((mediaItemId) => {
+    const mediaItem = tree.resourcesWithRoot.find(
+      (item) => item.id === mediaItemId
+    );
+    if (!mediaItem) return [];
+    return tree.flat(mediaItem);
+  });
+  const itemKeysToDelete = new Set(
+    itemsToDelete.map((item) => tree.idToPathMap.get(item.id))
+  );
+
+  return Object.fromEntries(
+    Object.entries(media).filter(([key]) => !itemKeysToDelete.has(key))
+  );
+};
+
+export const moveMediaInsideFolder = ({
+  sourceItemIds,
+  targetItemId,
+  media,
+  tree,
+}: {
+  sourceItemIds: string[];
+  targetItemId: string;
+  media: ResourceMap;
+  tree: ResourceTree;
+}) => {
+  const targetItemPath = tree.idToPathMap.get(targetItemId);
+  if (!targetItemPath) return media;
+
+  const sourceItemPaths = sourceItemIds
+    .map((id) => tree.idToPathMap.get(id))
+    .filter((path): path is string => Boolean(path));
+
+  return movePathsIntoTarget({
+    media,
+    sourceItemPaths,
+    targetItemPath,
+    tree,
+  });
+};
+
+export const getParentDirectories = (
+  resourceMap: ResourceMap,
+  folderId: string
+) => {
+  const tree = createResourceTree(resourceMap);
+
+  const indexPath = tree.findPath(rootResource, (item) => item.id === folderId);
+
+  if (!indexPath) return [rootResource];
+
+  return tree.accessPath(rootResource, indexPath);
+};
+
+export const renameResourceAndDescendantPaths = ({
+  newName,
+  selectedItemPath,
+  media,
+  tree,
+}: {
+  newName: string;
+  selectedItemPath: string;
+  media: ResourceMap;
+  tree: ResourceTree;
+}) => {
+  const mediaClone = { ...media };
+  const selectedItem = mediaClone[selectedItemPath];
+  if (!selectedItem) return mediaClone;
+
+  const parentPath = path.dirname(selectedItemPath);
+  const newItemPath = path.join(parentPath, newName);
+
+  const descendants = tree
+    .flat(selectedItem)
+    .map((item) => tree.idToPathMap.get(item.id));
+
+  // Update all descendants' paths
+  for (const descendantPath of descendants) {
+    if (!descendantPath) continue;
+
+    // Use the same approach as movePathsIntoTarget
+    const newDescendantPath = descendantPath.replace(
+      selectedItemPath,
+      newItemPath
+    );
+    mediaClone[newDescendantPath] = {
+      ...mediaClone[descendantPath],
+      path: newDescendantPath,
+    };
+    delete mediaClone[descendantPath];
+  }
+
+  return mediaClone;
+};

package/src/formatByteSize.ts

@@ -1,8 +0,0 @@
-const byteSizeUnits = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-
-export function formatByteSize(size: number) {
-  const unitIndex = Math.floor(Math.log(size) / Math.log(1024));
-  const unit = byteSizeUnits[unitIndex];
-  const value = size / Math.pow(1024, unitIndex);
-  return `${value.toFixed(1)} ${unit}`;
-}