Package Management

/**
 * Supported package managers
 */
type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';

/**
 * Detect which package manager is being used in a directory
 * @param dir - Directory to check (defaults to current working directory)
 * @returns Detected package manager
 */
function detectPackageManager(dir?: string): PackageManager;

/**
 * Get command-line commands for the detected package manager
 * @param packageManager - Package manager to get commands for
 * @returns Object with common commands for the package manager
 */
function getPackageManagerCommand(
  packageManager?: PackageManager
): {
  install: string;
  add: string;
  addDev: string;
  rm: string;
  exec: string;
  dlx: string;
  list: string;
};

/**
 * Get the version of the package manager
 * @param packageManager - Package manager to check
 * @returns Version string
 */
function getPackageManagerVersion(packageManager: PackageManager): string;

/**
 * Check if workspaces are enabled for the package manager
 * @param packageManager - Package manager to check
 * @param root - Workspace root directory
 * @returns Whether workspaces are enabled
 */
function isWorkspacesEnabled(
  packageManager: PackageManager, 
  root: string
): boolean;

import { 
  detectPackageManager, 
  getPackageManagerCommand,
  getPackageManagerVersion 
} from "@nrwl/devkit";

function handlePackageManager() {
  // Detect package manager
  const pm = detectPackageManager();
  console.log('Using package manager:', pm);
  
  // Get commands for the detected package manager
  const commands = getPackageManagerCommand(pm);
  console.log('Install command:', commands.install);
  console.log('Add dependency command:', commands.add);
  
  // Get version
  const version = getPackageManagerVersion(pm);
  console.log(`${pm} version:`, version);
  
  // Example usage of commands
  if (pm === 'yarn') {
    console.log('Add dev dependency:', `${commands.addDev} jest`);
  } else if (pm === 'pnpm') {
    console.log('Execute command:', `${commands.exec} nx build`);
  }
}

/**
 * Add dependencies to package.json
 * @param tree - Virtual file system tree
 * @param dependencies - Production dependencies to add
 * @param devDependencies - Development dependencies to add
 * @param packageJsonPath - Path to package.json (defaults to root)
 * @returns Generator callback to install packages
 */
function addDependenciesToPackageJson(
  tree: Tree,
  dependencies: Record<string, string>,
  devDependencies: Record<string, string>,
  packageJsonPath?: string
): GeneratorCallback;

/**
 * Remove dependencies from package.json
 * @param tree - Virtual file system tree
 * @param dependencies - Production dependencies to remove
 * @param devDependencies - Development dependencies to remove
 * @param packageJsonPath - Path to package.json (defaults to root)
 * @returns Generator callback to clean up node_modules if needed
 */
function removeDependenciesFromPackageJson(
  tree: Tree,
  dependencies: string[],
  devDependencies: string[],
  packageJsonPath?: string
): GeneratorCallback;

/**
 * Ensure a package is available, installing it if necessary
 * @template T - Expected package export type
 * @param packageName - Name of the package to ensure
 * @param version - Version to install if not present
 * @returns The package's exports
 */
function ensurePackage<T = any>(packageName: string, version: string): T;

import { 
  Tree,
  addDependenciesToPackageJson,
  removeDependenciesFromPackageJson,
  ensurePackage,
  GeneratorCallback 
} from "@nrwl/devkit";

function manageDependencies(tree: Tree): GeneratorCallback {
  // Add dependencies to the main package.json
  const installTask = addDependenciesToPackageJson(
    tree,
    {
      // Production dependencies
      'lodash': '^4.17.21',
      'axios': '^1.0.0'
    },
    {
      // Development dependencies
      '@types/lodash': '^4.14.0',
      'jest': '^29.0.0'
    }
  );
  
  // Add dependencies to a specific package.json
  const libInstallTask = addDependenciesToPackageJson(
    tree,
    { 'date-fns': '^2.29.0' },
    { '@types/date-fns': '^2.6.0' },
    'libs/my-lib/package.json'
  );
  
  // Remove outdated dependencies
  const removeTask = removeDependenciesFromPackageJson(
    tree,
    ['moment'], // Remove from dependencies
    ['@types/moment'], // Remove from devDependencies
  );
  
  // Return combined callback
  return async () => {
    await installTask();
    await libInstallTask();
    await removeTask();
  };
}

function useEnsurePackage() {
  // Dynamically ensure a package is available
  try {
    const chalk = ensurePackage('chalk', '^4.1.0');
    console.log(chalk.blue('Package is now available!'));
  } catch (error) {
    console.error('Failed to ensure package:', error);
  }
}

/**
 * Create a task to install packages
 * @param options - Installation options
 * @returns Generator callback that installs packages
 */
function installPackagesTask(options?: {
  /** Package manager to use */
  packageManager?: PackageManager;
  /** Working directory */
  cwd?: string;
  /** Whether to install in quiet mode */
  quiet?: boolean;
}): GeneratorCallback;

import { 
  Tree,
  installPackagesTask,
  detectPackageManager,
  GeneratorCallback 
} from "@nrwl/devkit";

export default async function myGenerator(tree: Tree, options: any) {
  // Generate files and modify package.json
  // ... file generation code ...
  
  // Create installation task
  const installTask = installPackagesTask({
    packageManager: detectPackageManager(),
    quiet: false
  });
  
  // Return the task to be executed after file changes are applied
  return installTask;
}

/**
 * Current Nx version being used
 */
const NX_VERSION: string;

import { NX_VERSION, addDependenciesToPackageJson } from "@nrwl/devkit";

function addNxDependencies(tree: Tree) {
  // Add Nx dependencies with the current version
  return addDependenciesToPackageJson(
    tree,
    {},
    {
      '@nx/workspace': NX_VERSION,
      '@nx/jest': NX_VERSION,
      '@nx/eslint-plugin': NX_VERSION
    }
  );
}

/**
 * Get workspace package.json
 * @param tree - Virtual file system tree
 * @returns Workspace package.json content
 */
function getWorkspacePackageJson(tree: Tree): {
  name?: string;
  version?: string;
  dependencies?: Record<string, string>;
  devDependencies?: Record<string, string>;
  workspaces?: string[] | { packages: string[] };
};

/**
 * Update workspace package.json
 * @param tree - Virtual file system tree
 * @param updater - Function to update package.json
 */
function updateWorkspacePackageJson(
  tree: Tree,
  updater: (packageJson: any) => any
): void;

/**
 * Check if a package is installed
 * @param packageName - Name of package to check
 * @param tree - Virtual file system tree (optional)
 * @returns Whether package is installed
 */
function isPackageInstalled(packageName: string, tree?: Tree): boolean;

/**
 * Get installed package version
 * @param packageName - Name of package to check
 * @param tree - Virtual file system tree (optional)
 * @returns Installed version or null if not installed
 */
function getInstalledPackageVersion(
  packageName: string, 
  tree?: Tree
): string | null;

import { 
  Tree,
  getWorkspacePackageJson,
  updateWorkspacePackageJson,
  isPackageInstalled,
  getInstalledPackageVersion 
} from "@nrwl/devkit";

function advancedPackageManagement(tree: Tree) {
  // Get workspace package.json
  const workspacePackageJson = getWorkspacePackageJson(tree);
  console.log('Workspace name:', workspacePackageJson.name);
  
  // Update workspace package.json
  updateWorkspacePackageJson(tree, (packageJson) => {
    return {
      ...packageJson,
      scripts: {
        ...packageJson.scripts,
        'build:all': 'nx run-many --target=build --all'
      }
    };
  });
  
  // Check if packages are installed
  if (isPackageInstalled('react', tree)) {
    const reactVersion = getInstalledPackageVersion('react', tree);
    console.log('React version:', reactVersion);
  }
  
  // Conditional dependency management
  if (!isPackageInstalled('@nx/react', tree)) {
    console.log('React plugin not installed');
  }
}