logos-storage-installer/src/utils/pathSelector.js

import path from "path";
import inquirer from "inquirer";
import boxen from "boxen";
import chalk from "chalk";
import fs from "fs";
import { filesystemSync } from "fs-filesystem";

function showMsg(msg) {
  console.log(
    boxen(chalk.white(msg), {
      padding: 1,
      margin: 1,
      borderStyle: "round",
      borderColor: "white",
      titleAlignment: "center",
    }),
  );
}

function getAvailableRoots() {
  const devices = filesystemSync();
  var mountPoints = [];
  Object.keys(devices).forEach(function (key) {
    var val = devices[key];
    val.volumes.forEach(function (volume) {
      mountPoints.push(volume.mountPoint);
    });
  });

  if (mountPoints.length < 1) {
    throw new Error("Failed to detect file system devices.");
  }
  return mountPoints;
}

function splitPath(str) {
  return str.replaceAll("\\", "/").split("/");
}

function dropEmptyParts(parts) {
  var result = [];
  parts.forEach(function (part) {
    if (part.length > 0) {
      result.push(part);
    }
  });
  return result;
}

function combine(parts) {
  const toJoin = dropEmptyParts(parts);
  if (toJoin.length == 1) return toJoin[0];
  return path.join(...toJoin);
}

function combineWith(parts, extra) {
  const toJoin = dropEmptyParts(parts);
  if (toJoin.length == 1) return path.join(toJoin[0], extra);
  return path.join(...toJoin, extra);
}

function showCurrent(currentPath) {
  const len = currentPath.length;
  showMsg(`Current path: [${len}]\n` + combine(currentPath));

  if (len < 2) {
    showMsg(
      "Warning - Known issue:\n" +
        "Path selection does not work in root paths on some platforms.\n" +
        'Use "Enter path" or "Create new folder" to navigate and create folders\n' +
        "if this is the case for you.",
    );
  }
}

function hasValidRoot(roots, checkPath) {
  if (checkPath.length < 1) return false;
  var result = false;
  roots.forEach(function (root) {
    if (root.toLowerCase() == checkPath[0].toLowerCase()) {
      console.log("valid root: " + combine(checkPath));
      result = true;
    }
  });
  if (!result) console.log("invalid root: " + combine(checkPath));
  return result;
}

async function showMain(currentPath) {
  showCurrent(currentPath);
  const { choice } = await inquirer
    .prompt([
      {
        type: "list",
        name: "choice",
        message: "Select an option:",
        choices: [
          "1. Enter path",
          "2. Go up one",
          "3. Go down one",
          "4. Create new folder here",
          "5. Select this path",
          "6. Cancel",
        ],
        pageSize: 6,
        loop: true,
      },
    ])
    .catch(() => {
      handleExit();
      return { choice: "6" };
    });

  return choice;
}

export async function showPathSelector(startingPath, pathMustExist) {
  const roots = getAvailableRoots();
  var currentPath = splitPath(startingPath);
  if (!hasValidRoot(roots, currentPath)) {
    currentPath = [roots[0]];
  }

  while (true) {
    const choice = await showMain(currentPath);

    var newCurrentPath = currentPath;
    switch (choice.split(".")[0]) {
      case "1":
        newCurrentPath = await enterPath(currentPath, pathMustExist);
        break;
      case "2":
        newCurrentPath = upOne(currentPath);
        break;
      case "3":
        newCurrentPath = await downOne(currentPath);
        break;
      case "4":
        newCurrentPath = await createSubDir(currentPath, pathMustExist);
        break;
      case "5":
        if (pathMustExist && !isDir(combine(currentPath))) {
          console.log("Current path does not exist.");
          break;
        } else {
          return combine(currentPath);
        }
      case "6":
        return combine(currentPath);
    }

    if (hasValidRoot(roots, newCurrentPath)) {
      currentPath = newCurrentPath;
    } else {
      console.log("Selected path has no valid root.");
    }
  }
}

async function enterPath(currentPath, pathMustExist) {
  const response = await inquirer.prompt([
    {
      type: "input",
      name: "path",
      message: "Enter Path:",
    },
  ]);

  const newPath = response.path;
  if (pathMustExist && !isDir(newPath)) {
    console.log("The entered path does not exist.");
    return currentPath;
  }
  return splitPath(response.path);
}

function upOne(currentPath) {
  return currentPath.slice(0, currentPath.length - 1);
}

export function isDir(dir) {
  try {
    return fs.lstatSync(dir).isDirectory();
  } catch {
    return false;
  }
}

function isSubDir(currentPath, entry) {
  const newPath = combineWith(currentPath, entry);
  return isDir(newPath);
}

function getSubDirOptions(currentPath) {
  const fullPath = combine(currentPath);
  const entries = fs.readdirSync(fullPath);
  var result = [];
  var counter = 1;
  entries.forEach(function (entry) {
    if (isSubDir(currentPath, entry)) {
      result.push(counter + ". " + entry);
      counter = counter + 1;
    }
  });
  return result;
}

async function downOne(currentPath) {
  const options = getSubDirOptions(currentPath);
  if (options.length == 0) {
    console.log("There are no subdirectories here.");
    return currentPath;
  }

  const { choice } = await inquirer
    .prompt([
      {
        type: "list",
        name: "choice",
        message: "Select an subdir:",
        choices: options,
        pageSize: options.length,
        loop: true,
      },
    ])
    .catch(() => {
      return currentPath;
    });

  const subDir = choice.split(". ")[1];
  return [...currentPath, subDir];
}

async function createSubDir(currentPath, pathMustExist) {
  const response = await inquirer.prompt([
    {
      type: "input",
      name: "name",
      message: "Enter name:",
    },
  ]);

  const name = response.name;
  if (name.length < 1) return;

  const fullDir = combineWith(currentPath, name);
  if (pathMustExist && !isDir(fullDir)) {
    fs.mkdirSync(fullDir);
  }
  return [...currentPath, name];
}