@turbo/workspaces 0.0.1

package/dist/index.js

@@ -0,0 +1,840 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MANAGERS: () => managers_default,
+  convertMonorepo: () => convertMonorepo,
+  getWorkspaceDetails: () => getWorkspaceDetails,
+  install: () => install_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_turbo_utils = require("turbo-utils");
+
+// src/errors.ts
+var ConvertError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConvertError";
+    Error.captureStackTrace(this, ConvertError);
+  }
+};
+
+// src/managers/pnpm.ts
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+var import_execa = __toESM(require("execa"));
+
+// src/updateDependencies.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_chalk = __toESM(require("chalk"));
+var import_path2 = __toESM(require("path"));
+
+// src/utils.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_js_yaml = __toESM(require("js-yaml"));
+var PACKAGE_MANAGER_REGEX = /^(?!_)(.+)@(.+)$/;
+function getPackageJson({
+  workspaceRoot
+}) {
+  const packageJsonPath = import_path.default.join(workspaceRoot, "package.json");
+  try {
+    return import_fs_extra.default.readJsonSync(packageJsonPath, "utf8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err) {
+      if (err.code === "ENOENT") {
+        throw new ConvertError(`no "package.json" found at ${workspaceRoot}`);
+      }
+      if (err.code === "EJSONPARSE") {
+        throw new ConvertError(`failed to parse "package.json" at ${workspaceRoot}`);
+      }
+    }
+    throw new Error(`unexpected error reading "package.json" at ${workspaceRoot}`);
+  }
+}
+function getWorkspacePackageManager({
+  workspaceRoot
+}) {
+  const { packageManager } = getPackageJson({ workspaceRoot });
+  if (packageManager) {
+    try {
+      const match = packageManager.match(PACKAGE_MANAGER_REGEX);
+      if (match) {
+        const [_, manager] = match;
+        return manager;
+      }
+    } catch (err) {
+    }
+  }
+  return void 0;
+}
+function getWorkspaceName({
+  workspaceRoot
+}) {
+  const packageJson = getPackageJson({ workspaceRoot });
+  if (packageJson.name) {
+    return packageJson.name;
+  }
+  const workspaceDirectory = import_path.default.basename(workspaceRoot);
+  return workspaceDirectory;
+}
+function getPnpmWorkspaces({
+  workspaceRoot
+}) {
+  const workspaceFile = import_path.default.join(workspaceRoot, "pnpm-workspace.yaml");
+  if (import_fs_extra.default.existsSync(workspaceFile)) {
+    try {
+      const workspaceConfig = import_js_yaml.default.load(import_fs_extra.default.readFileSync(workspaceFile, "utf8"));
+      if (workspaceConfig instanceof Object && "packages" in workspaceConfig && Array.isArray(workspaceConfig.packages)) {
+        return workspaceConfig.packages;
+      }
+    } catch (err) {
+      throw new ConvertError(`failed to parse ${workspaceFile}`);
+    }
+  }
+  return [];
+}
+function expandPaths({
+  root,
+  lockFile,
+  workspaceConfig
+}) {
+  const fromRoot = (p) => import_path.default.join(root, p);
+  const paths = {
+    root,
+    lockfile: fromRoot(lockFile),
+    packageJson: fromRoot("package.json"),
+    nodeModules: fromRoot("node_modules")
+  };
+  if (workspaceConfig) {
+    paths.workspaceConfig = fromRoot(workspaceConfig);
+  }
+  return paths;
+}
+function expandWorkspaces({
+  workspaceRoot,
+  workspaceGlobs
+}) {
+  if (!workspaceGlobs) {
+    return [];
+  }
+  return workspaceGlobs.flatMap((workspaceGlob) => {
+    const workspacePackageJsonGlob = `${workspaceGlob}/package.json`;
+    return import_fast_glob.default.sync(workspacePackageJsonGlob, {
+      onlyFiles: true,
+      absolute: true,
+      cwd: workspaceRoot
+    });
+  }).map((workspacePackageJson) => {
+    const workspaceRoot2 = import_path.default.dirname(workspacePackageJson);
+    const name = getWorkspaceName({ workspaceRoot: workspaceRoot2 });
+    return {
+      name,
+      paths: {
+        root: workspaceRoot2,
+        packageJson: workspacePackageJson,
+        nodeModules: import_path.default.join(workspaceRoot2, "node_modules")
+      }
+    };
+  });
+}
+function directoryInfo({ directory }) {
+  const dir = import_path.default.resolve(process.cwd(), directory);
+  return { exists: import_fs_extra.default.existsSync(dir), absolute: dir };
+}
+
+// src/updateDependencies.ts
+function updateDependencyList({
+  dependencyList,
+  project,
+  to
+}) {
+  const updated = [];
+  project.workspaceData.workspaces.forEach((workspace) => {
+    const { name } = workspace;
+    if (dependencyList[name]) {
+      const workspaceVersion = dependencyList[name];
+      const version = workspaceVersion.startsWith("workspace:") ? workspaceVersion.slice("workspace:".length) : workspaceVersion;
+      dependencyList[name] = to.name === "pnpm" ? `workspace:${version}` : version;
+      updated.push(name);
+    }
+  });
+  return { dependencyList, updated };
+}
+function updateDependencies({
+  project,
+  workspace,
+  to,
+  logger,
+  options
+}) {
+  if (["yarn", "npm"].includes(to.name) && ["yarn", "npm"].includes(project.packageManager)) {
+    return;
+  }
+  const workspacePackageJson = getPackageJson({
+    workspaceRoot: workspace.paths.root
+  });
+  const stats = {
+    dependencies: [],
+    devDependencies: [],
+    peerDependencies: [],
+    optionalDependencies: []
+  };
+  const allDependencyKeys = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ];
+  allDependencyKeys.forEach((depKey) => {
+    const depList = workspacePackageJson[depKey];
+    if (depList) {
+      const { updated, dependencyList } = updateDependencyList({
+        dependencyList: depList,
+        project,
+        to
+      });
+      workspacePackageJson[depKey] = dependencyList;
+      stats[depKey] = updated;
+    }
+  });
+  const toLog = (key) => {
+    const total = stats[key].length;
+    if (total > 0) {
+      return `${import_chalk.default.green(total.toString())} ${key}`;
+    }
+    return void 0;
+  };
+  const allChanges = allDependencyKeys.map(toLog).filter(Boolean);
+  const workspaceLocation = `./${import_path2.default.relative(project.paths.root, workspace.paths.packageJson)}`;
+  if (allChanges.length >= 1) {
+    let logLine = "updating";
+    allChanges.forEach((stat, idx) => {
+      if (allChanges.length === 1) {
+        logLine += ` ${stat} in ${workspaceLocation}`;
+      } else {
+        if (idx === allChanges.length - 1) {
+          logLine += `and ${stat} in ${workspaceLocation}`;
+        } else {
+          logLine += ` ${stat}, `;
+        }
+      }
+    });
+    logger.workspaceStep(logLine);
+  } else {
+    logger.workspaceStep(`no workspace dependencies found in ${workspaceLocation}`);
+  }
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra2.default.writeJSONSync(workspace.paths.packageJson, workspacePackageJson, {
+      spaces: 2
+    });
+  }
+}
+
+// src/managers/pnpm.ts
+async function detect(args) {
+  const lockFile = import_path3.default.join(args.workspaceRoot, "pnpm-lock.yaml");
+  const workspaceFile = import_path3.default.join(args.workspaceRoot, "pnpm-workspace.yaml");
+  const packageManager = getWorkspacePackageManager({
+    workspaceRoot: args.workspaceRoot
+  });
+  return import_fs_extra3.default.existsSync(lockFile) || import_fs_extra3.default.existsSync(workspaceFile) || packageManager === "pnpm";
+}
+async function read(args) {
+  const isPnpm = await detect(args);
+  if (!isPnpm) {
+    throw new ConvertError("Not a pnpm project");
+  }
+  return {
+    name: getWorkspaceName(args),
+    packageManager: "pnpm",
+    paths: expandPaths({
+      root: args.workspaceRoot,
+      lockFile: "pnpm-lock.yaml",
+      workspaceConfig: "pnpm-workspace.yaml"
+    }),
+    workspaceData: {
+      globs: getPnpmWorkspaces(args),
+      workspaces: expandWorkspaces({
+        workspaceGlobs: getPnpmWorkspaces(args),
+        ...args
+      })
+    }
+  };
+}
+async function create(args) {
+  const { project, to, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  logger.rootHeader();
+  packageJson.packageManager = `${to.name}@${to.version}`;
+  logger.rootStep(`adding "packageManager" field to ${project.name} root "package.json"`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra3.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    if (hasWorkspaces) {
+      logger.rootStep(`adding "pnpm-workspace.yaml"`);
+      import_fs_extra3.default.writeFileSync(import_path3.default.join(project.paths.root, "pnpm-workspace.yaml"), `packages:
+${project.workspaceData.globs.map((w) => `  - "${w}"`).join("\n")}`);
+    }
+  }
+  if (hasWorkspaces) {
+    updateDependencies({
+      workspace: { name: "root", paths: project.paths },
+      project,
+      to,
+      logger,
+      options
+    });
+    logger.workspaceHeader();
+    project.workspaceData.workspaces.forEach((workspace) => updateDependencies({ workspace, project, to, logger, options }));
+  }
+}
+async function remove(args) {
+  const { project, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Removing ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  if (project.paths.workspaceConfig && hasWorkspaces) {
+    logger.subStep(`removing "pnpm-workspace.yaml"`);
+    if (!(options == null ? void 0 : options.dry)) {
+      import_fs_extra3.default.rmSync(project.paths.workspaceConfig, { force: true });
+    }
+  }
+  logger.subStep(`removing "packageManager" field in ${project.name} root "package.json"`);
+  delete packageJson.packageManager;
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra3.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    const allModulesDirs = [
+      project.paths.nodeModules,
+      ...project.workspaceData.workspaces.map((w) => w.paths.nodeModules)
+    ];
+    try {
+      logger.subStep(`removing "node_modules"`);
+      await Promise.all(allModulesDirs.map((dir) => import_fs_extra3.default.rm(dir, { recursive: true, force: true })));
+    } catch (err) {
+      throw new ConvertError("Failed to remove node_modules");
+    }
+  }
+}
+async function clean(args) {
+  const { project, logger, options } = args;
+  logger.subStep(`removing ${import_path3.default.relative(project.paths.root, project.paths.lockfile)}`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra3.default.rmSync(project.paths.lockfile, { force: true });
+  }
+}
+async function convertLock(args) {
+  const { project, logger, options } = args;
+  if (project.packageManager !== "pnpm") {
+    logger.subStep(`converting ${import_path3.default.relative(project.paths.root, project.paths.lockfile)} to pnpm-lock.yaml`);
+    if (!(options == null ? void 0 : options.dry) && import_fs_extra3.default.existsSync(project.paths.lockfile)) {
+      try {
+        await (0, import_execa.default)("pnpm", ["import"], {
+          stdio: "ignore",
+          cwd: project.paths.root
+        });
+      } finally {
+        import_fs_extra3.default.rmSync(project.paths.lockfile, { force: true });
+      }
+    }
+  }
+}
+var pnpm = {
+  detect,
+  read,
+  create,
+  remove,
+  clean,
+  convertLock
+};
+var pnpm_default = pnpm;
+
+// src/managers/npm.ts
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+async function detect2(args) {
+  const lockFile = import_path4.default.join(args.workspaceRoot, "package-lock.json");
+  const packageManager = getWorkspacePackageManager({
+    workspaceRoot: args.workspaceRoot
+  });
+  return import_fs_extra4.default.existsSync(lockFile) || packageManager === "npm";
+}
+async function read2(args) {
+  const isNpm = await detect2(args);
+  if (!isNpm) {
+    throw new ConvertError("Not an npm project");
+  }
+  const packageJson = getPackageJson(args);
+  return {
+    name: getWorkspaceName(args),
+    packageManager: "npm",
+    paths: expandPaths({
+      root: args.workspaceRoot,
+      lockFile: "package-lock.json"
+    }),
+    workspaceData: {
+      globs: packageJson.workspaces || [],
+      workspaces: expandWorkspaces({
+        workspaceGlobs: packageJson.workspaces,
+        ...args
+      })
+    }
+  };
+}
+async function create2(args) {
+  const { project, options, to, logger } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  logger.rootHeader();
+  logger.rootStep(`adding "packageManager" field to ${project.name} root "package.json"`);
+  packageJson.packageManager = `${to.name}@${to.version}`;
+  if (hasWorkspaces) {
+    logger.rootStep(`adding "workspaces" field to ${project.name} root "package.json"`);
+    packageJson.workspaces = project.workspaceData.globs;
+    updateDependencies({
+      workspace: { name: "root", paths: project.paths },
+      project,
+      to,
+      logger,
+      options
+    });
+    logger.workspaceHeader();
+    project.workspaceData.workspaces.forEach((workspace) => updateDependencies({ workspace, project, to, logger, options }));
+  }
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra4.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+  }
+}
+async function remove2(args) {
+  const { project, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  if (hasWorkspaces) {
+    logger.subStep(`removing "workspaces" field in ${project.name} root "package.json"`);
+    delete packageJson.workspaces;
+  }
+  logger.subStep(`removing "packageManager" field in ${project.name} root "package.json"`);
+  delete packageJson.packageManager;
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra4.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    const allModulesDirs = [
+      project.paths.nodeModules,
+      ...project.workspaceData.workspaces.map((w) => w.paths.nodeModules)
+    ];
+    try {
+      logger.subStep(`removing "node_modules"`);
+      await Promise.all(allModulesDirs.map((dir) => import_fs_extra4.default.rm(dir, { recursive: true, force: true })));
+    } catch (err) {
+      throw new ConvertError("Failed to remove node_modules");
+    }
+  }
+}
+async function clean2(args) {
+  const { project, logger, options } = args;
+  logger.subStep(`removing ${import_path4.default.relative(project.paths.root, project.paths.lockfile)}`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra4.default.rmSync(project.paths.lockfile, { force: true });
+  }
+}
+async function convertLock2(args) {
+  const { project, options } = args;
+  if (project.packageManager !== "npm") {
+    if (!(options == null ? void 0 : options.dry)) {
+      import_fs_extra4.default.rmSync(project.paths.lockfile, { force: true });
+    }
+  }
+}
+var npm = {
+  detect: detect2,
+  read: read2,
+  create: create2,
+  remove: remove2,
+  clean: clean2,
+  convertLock: convertLock2
+};
+var npm_default = npm;
+
+// src/managers/yarn.ts
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path5 = __toESM(require("path"));
+async function detect3(args) {
+  const lockFile = import_path5.default.join(args.workspaceRoot, "yarn.lock");
+  const packageManager = getWorkspacePackageManager({
+    workspaceRoot: args.workspaceRoot
+  });
+  return import_fs_extra5.default.existsSync(lockFile) || packageManager === "yarn";
+}
+async function read3(args) {
+  const isYarn = await detect3(args);
+  if (!isYarn) {
+    throw new ConvertError("Not a yarn project");
+  }
+  const packageJson = getPackageJson(args);
+  return {
+    name: getWorkspaceName(args),
+    packageManager: "yarn",
+    paths: expandPaths({
+      root: args.workspaceRoot,
+      lockFile: "yarn.lock"
+    }),
+    workspaceData: {
+      globs: packageJson.workspaces || [],
+      workspaces: expandWorkspaces({
+        workspaceGlobs: packageJson.workspaces,
+        ...args
+      })
+    }
+  };
+}
+async function create3(args) {
+  const { project, to, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Creating ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  logger.rootHeader();
+  logger.rootStep(`adding "packageManager" field to ${import_path5.default.relative(project.paths.root, project.paths.packageJson)}`);
+  packageJson.packageManager = `${to.name}@${to.version}`;
+  if (hasWorkspaces) {
+    logger.rootStep(`adding "workspaces" field to ${import_path5.default.relative(project.paths.root, project.paths.packageJson)}`);
+    packageJson.workspaces = project.workspaceData.globs;
+    updateDependencies({
+      workspace: { name: "root", paths: project.paths },
+      project,
+      to,
+      logger,
+      options
+    });
+    logger.workspaceHeader();
+    project.workspaceData.workspaces.forEach((workspace) => updateDependencies({ workspace, project, to, logger, options }));
+  }
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra5.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+  }
+}
+async function remove3(args) {
+  const { project, logger, options } = args;
+  const hasWorkspaces = project.workspaceData.globs.length > 0;
+  logger.mainStep(`Removing ${project.packageManager}${hasWorkspaces ? "workspaces" : ""}`);
+  const packageJson = getPackageJson({ workspaceRoot: project.paths.root });
+  if (hasWorkspaces) {
+    logger.subStep(`removing "workspaces" field in ${project.name} root "package.json"`);
+    delete packageJson.workspaces;
+  }
+  logger.subStep(`removing "packageManager" field in ${project.name} root "package.json"`);
+  delete packageJson.packageManager;
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra5.default.writeJSONSync(project.paths.packageJson, packageJson, { spaces: 2 });
+    const allModulesDirs = [
+      project.paths.nodeModules,
+      ...project.workspaceData.workspaces.map((w) => w.paths.nodeModules)
+    ];
+    try {
+      logger.subStep(`removing "node_modules"`);
+      await Promise.all(allModulesDirs.map((dir) => import_fs_extra5.default.rm(dir, { recursive: true, force: true })));
+    } catch (err) {
+      throw new ConvertError("Failed to remove node_modules");
+    }
+  }
+}
+async function clean3(args) {
+  const { project, logger, options } = args;
+  logger.subStep(`removing ${import_path5.default.relative(project.paths.root, project.paths.lockfile)}`);
+  if (!(options == null ? void 0 : options.dry)) {
+    import_fs_extra5.default.rmSync(project.paths.lockfile, { force: true });
+  }
+}
+async function convertLock3(args) {
+  const { project, options } = args;
+  if (project.packageManager !== "yarn") {
+    if (!(options == null ? void 0 : options.dry)) {
+      import_fs_extra5.default.rmSync(project.paths.lockfile, { force: true });
+    }
+  }
+}
+var yarn = {
+  detect: detect3,
+  read: read3,
+  create: create3,
+  remove: remove3,
+  clean: clean3,
+  convertLock: convertLock3
+};
+var yarn_default = yarn;
+
+// src/managers/index.ts
+var MANAGERS = {
+  pnpm: pnpm_default,
+  yarn: yarn_default,
+  npm: npm_default
+};
+var managers_default = MANAGERS;
+
+// src/getWorkspaceDetails.ts
+async function getWorkspaceDetails({
+  root
+}) {
+  const { exists, absolute: workspaceRoot } = directoryInfo({
+    directory: root
+  });
+  if (!exists) {
+    throw new ConvertError(`Could not find directory at ${workspaceRoot}. Ensure the directory exists.`);
+  }
+  for (const { detect: detect4, read: read4 } of Object.values(managers_default)) {
+    if (await detect4({ workspaceRoot })) {
+      return read4({ workspaceRoot });
+    }
+  }
+  throw new ConvertError("Could not determine workspace manager. Add `packageManager` to `package.json` or ensure a lockfile is present.");
+}
+
+// src/convert.ts
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/install.ts
+var import_execa2 = __toESM(require("execa"));
+var import_ora = __toESM(require("ora"));
+var import_semver = require("semver");
+var PACKAGE_MANAGERS = {
+  npm: [
+    {
+      name: "npm",
+      template: "npm",
+      command: "npm",
+      installArgs: ["install"],
+      version: "latest",
+      executable: "npx",
+      semver: "*"
+    }
+  ],
+  pnpm: [
+    {
+      name: "pnpm6",
+      template: "pnpm",
+      command: "pnpm",
+      installArgs: ["install"],
+      version: "latest-6",
+      executable: "pnpx",
+      semver: "6.x"
+    },
+    {
+      name: "pnpm",
+      template: "pnpm",
+      command: "pnpm",
+      installArgs: ["install"],
+      version: "latest",
+      executable: "pnpm dlx",
+      semver: ">=7"
+    }
+  ],
+  yarn: [
+    {
+      name: "yarn",
+      template: "yarn",
+      command: "yarn",
+      installArgs: ["install"],
+      version: "1.x",
+      executable: "npx",
+      semver: "<2"
+    },
+    {
+      name: "berry",
+      template: "berry",
+      command: "yarn",
+      installArgs: ["install", "--no-immutable"],
+      version: "stable",
+      executable: "yarn dlx",
+      semver: ">=2"
+    }
+  ]
+};
+async function install(args) {
+  const { to, logger, options } = args;
+  let packageManager = PACKAGE_MANAGERS[to.name].find((manager) => (0, import_semver.satisfies)(to.version, manager.semver));
+  if (!packageManager) {
+    throw new ConvertError("Unsupported package manager version.");
+  }
+  logger.subStep(`running "${packageManager.command} ${packageManager.installArgs}"`);
+  if (!(options == null ? void 0 : options.dry)) {
+    let spinner;
+    if (options == null ? void 0 : options.interactive) {
+      spinner = (0, import_ora.default)({
+        text: "Installing dependencies...",
+        spinner: {
+          frames: logger.installerFrames()
+        }
+      }).start();
+    }
+    try {
+      await (0, import_execa2.default)(packageManager.command, packageManager.installArgs, {
+        cwd: args.project.paths.root
+      });
+      logger.subStep(`dependencies installed`);
+    } catch (err) {
+      logger.subStepFailure(`failed to install dependencies`);
+      throw err;
+    } finally {
+      if (spinner) {
+        spinner.stop();
+      }
+    }
+  }
+}
+var install_default = install;
+
+// src/convert.ts
+async function convert({
+  project,
+  to,
+  logger,
+  options
+}) {
+  logger.header(`Converting project from ${project.packageManager} to ${to.name}.`);
+  if (project.packageManager == to.name) {
+    throw new ConvertError("You are already using this package manager");
+  }
+  await managers_default[project.packageManager].remove({
+    project,
+    to,
+    logger,
+    options
+  });
+  await managers_default[to.name].create({ project, to, logger, options });
+  logger.mainStep("Installing dependencies");
+  if (!(options == null ? void 0 : options.skipInstall)) {
+    await managers_default[to.name].convertLock({ project, logger, options });
+    await install_default({ project, to, logger, options });
+  } else {
+    logger.subStep(import_chalk2.default.yellow("Skipping install"));
+  }
+  logger.mainStep(`Cleaning up ${project.packageManager} workspaces`);
+  await managers_default[project.packageManager].clean({ project, logger });
+}
+var convert_default = convert;
+
+// src/logger.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_gradient_string = __toESM(require("gradient-string"));
+var INDENTATION = 2;
+var Logger = class {
+  constructor({
+    interactive,
+    dry
+  } = {}) {
+    this.interactive = interactive != null ? interactive : true;
+    this.dry = dry != null ? dry : false;
+    this.step = 1;
+  }
+  logger(...args) {
+    if (this.interactive) {
+      console.log(...args);
+    }
+  }
+  indented(level, ...args) {
+    this.logger(" ".repeat(INDENTATION * level), ...args);
+  }
+  header(title) {
+    this.blankLine();
+    this.logger(import_chalk3.default.bold(title));
+  }
+  installerFrames() {
+    const prefix = `${" ".repeat(INDENTATION)} - ${this.dry ? import_chalk3.default.yellow("SKIPPED | ") : import_chalk3.default.green("OK | ")}`;
+    return [`${prefix}   `, `${prefix}>  `, `${prefix}>> `, `${prefix}>>>`];
+  }
+  gradient(text) {
+    const turboGradient = (0, import_gradient_string.default)("#0099F7", "#F11712");
+    return turboGradient(text.toString());
+  }
+  hero() {
+    this.logger(import_chalk3.default.bold(this.gradient(`
+>>> TURBOREPO
+`)));
+  }
+  info(...args) {
+    this.logger(...args);
+  }
+  mainStep(title) {
+    this.blankLine();
+    this.logger(`${this.step}. ${import_chalk3.default.underline(title)}`);
+    this.step += 1;
+  }
+  subStep(...args) {
+    this.logger(" ".repeat(INDENTATION), `-`, this.dry ? import_chalk3.default.yellow("SKIPPED |") : import_chalk3.default.green("OK |"), ...args);
+  }
+  subStepFailure(...args) {
+    this.logger(" ".repeat(INDENTATION), `-`, import_chalk3.default.red("ERROR |"), ...args);
+  }
+  rootHeader() {
+    this.blankLine();
+    this.indented(2, "Root:");
+  }
+  rootStep(...args) {
+    this.logger(" ".repeat(INDENTATION * 3), `-`, this.dry ? import_chalk3.default.yellow("SKIPPED |") : import_chalk3.default.green("OK |"), ...args);
+  }
+  workspaceHeader() {
+    this.blankLine();
+    this.indented(2, "Workspaces:");
+  }
+  workspaceStep(...args) {
+    this.logger(" ".repeat(INDENTATION * 3), `-`, this.dry ? import_chalk3.default.yellow("SKIPPED |") : import_chalk3.default.green("OK |"), ...args);
+  }
+  blankLine() {
+    this.logger();
+  }
+  error(...args) {
+    console.error(...args);
+  }
+};
+
+// src/index.ts
+async function convertMonorepo({
+  root,
+  to,
+  options
+}) {
+  const logger = new Logger({ ...options, interactive: false });
+  const [project, availablePackageManagers] = await Promise.all([
+    getWorkspaceDetails({ root }),
+    (0, import_turbo_utils.getAvailablePackageManagers)()
+  ]);
+  await convert_default({
+    project,
+    to: {
+      name: to,
+      version: availablePackageManagers[to].version
+    },
+    logger,
+    options
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MANAGERS,
+  convertMonorepo,
+  getWorkspaceDetails,
+  install
+});