@mschauer5/spfx-toolkit 1.0.1

package/src/commands/build.command.ts

@@ -0,0 +1,48 @@
+import spawn from 'cross-spawn';
+import { logger, util } from '../common';
+import { detect } from 'detect-package-manager';
+
+const packageRun = async (): Promise<void> => {
+  try {
+    const usercommand = await detect();
+
+    try {
+      const args = ['run', 'build'];
+      spawn.sync(usercommand, args, { stdio: 'inherit' });
+    } catch (error) {
+      logger.log(error);
+    }
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+export const run = async (usePackage: boolean, useDefault: boolean) => {
+  try {
+    let buildLocation = usePackage ? 'package' : await util.getScriptNameRunType('build');
+    if (buildLocation === undefined) {
+      buildLocation = 'default';
+    }
+
+    if (useDefault) {
+      buildLocation = usePackage ? 'package' : 'default';
+      await util.addScriptNameRunType('build', buildLocation);
+    }
+
+    if (buildLocation === 'package') {
+      await packageRun();
+      return;
+    }
+
+    const isGulp = await util.isUsingGulp();
+    let args = ['heft', 'build'];
+    if (isGulp) {
+      args = ['gulp', 'build'];
+    }
+
+    spawn.sync('npx', args, { stdio: 'inherit' });
+    return;
+  } catch (error) {
+    logger.error(error);
+  }
+};

package/src/commands/bundle.command.ts

@@ -0,0 +1,60 @@
+import spawn from 'cross-spawn';
+import { logger, util } from '../common';
+import { detect } from 'detect-package-manager';
+
+const packageRun = async (): Promise<void> => {
+  try {
+    const usercommand = await detect();
+
+    try {
+      const args = ['run', 'bundle'];
+      spawn.sync(usercommand, args, { stdio: 'inherit' });
+    } catch (error) {
+      logger.log(error);
+    }
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+export const run = async (usePackage: boolean, useDefault: boolean) => {
+  try {
+    let bundleLocation = usePackage ? 'package' : await util.getScriptNameRunType('bundle');
+    if (bundleLocation === undefined) {
+      bundleLocation = 'default';
+    }
+
+    if (useDefault) {
+      bundleLocation = usePackage ? 'package' : 'default';
+      await util.addScriptNameRunType('bundle', bundleLocation);
+    }
+
+    if (bundleLocation === 'package') {
+      await packageRun();
+      return;
+    }
+
+    const isGulp = await util.isUsingGulp();
+    if (isGulp) {
+      let args = ['clean'];
+      spawn.sync('gulp', args, { stdio: 'inherit' });
+
+      args = ['bundle', '--ship'];
+      spawn.sync('gulp', args, { stdio: 'inherit' });
+
+      args = ['package-solution', '--ship'];
+      spawn.sync('gulp', args, { stdio: 'inherit' });
+      return;
+    }
+
+    // SPFx 1.22+ (Heft): build and package using Heft
+    let args = ['heft', 'build', '--clean'];
+    spawn.sync('npx', args, { stdio: 'inherit' });
+
+    args = ['heft', 'package'];
+    spawn.sync('npx', args, { stdio: 'inherit' });
+    return;
+  } catch (error) {
+    logger.error(error);
+  }
+};

package/src/commands/eslint.command.ts

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import { constants, logger } from '../common';
+
+const eslintFileName = '.eslintrc.js';
+const eslint = path.resolve(constants.WORKING_DIRECTORY, eslintFileName);
+const eslintBackupFileName = '.env-eslintrc-bk.js';
+const eslintBackup = path.resolve(constants.WORKING_DIRECTORY, eslintBackupFileName);
+export const backupEslint = () => {
+  if (!fs.existsSync(eslint)) {
+    logger.error(`No ${eslintFileName} found!`);
+    return;
+  }
+  fs.copyFileSync(eslint, eslintBackupFileName);
+  logger.info(`${eslintFileName} backed up to ${eslintBackupFileName}`);
+};
+
+export const restoreEslint = () => {
+  if (!fs.existsSync(eslintBackup)) {
+    logger.error(`No ${eslintBackupFileName} found!`);
+    return;
+  }
+  fs.copyFileSync(eslintBackup, eslintFileName);
+  logger.info(`${eslintFileName} restored from ${eslintBackupFileName}`);
+
+  // remove the backup file
+  fs.unlinkSync(eslintBackup);
+};

package/src/commands/index.ts

@@ -0,0 +1,7 @@
+import * as alias from './alias.command';
+import * as eslint from './eslint.command';
+import * as version from './version.command';
+import * as serve from './serve.command';
+import * as build from './build.command';
+import * as bundle from './bundle.command';
+export { alias, eslint, version, serve, build, bundle };

package/src/commands/serve.command.ts

@@ -0,0 +1,13 @@
+import { logger, util } from '../common';
+
+export const run = async (): Promise<void> => {
+  logger.info('Starting the SPFx development server...');
+  util.isUsingGulp().then((usingGulp) => {
+    if (usingGulp) {
+      logger.info('Gulp detected. Running gulp serve...');
+    } else {
+      logger.error('Gulp not detected. Please ensure you have gulp installed and configured.');
+    }
+  });
+  // Implementation of the serve command goes here
+};

package/src/commands/version.command.ts

@@ -0,0 +1,104 @@
+import path from 'path';
+import { constants, logger } from '../common';
+import fs from 'fs';
+
+const syncPackageSolution = (version: string) => {
+  const packageSolutionPath = path.resolve(constants.WORKING_DIRECTORY, 'config/package-solution.json');
+  const packageSolution = JSON.parse(fs.readFileSync(packageSolutionPath, 'utf-8'));
+  packageSolution.solution.version = version + '.0';
+  fs.writeFileSync(packageSolutionPath, JSON.stringify(packageSolution, null, 2));
+  logger.success(`updated sharepoint version to ${packageSolution.solution.version}`);
+};
+
+const updatePackage = (version: string) => {
+  const fileFullPath = path.resolve(constants.WORKING_DIRECTORY, 'package.json');
+  const json = JSON.parse(fs.readFileSync(fileFullPath, 'utf-8'));
+  json.version = version;
+  fs.writeFileSync(fileFullPath, JSON.stringify(json, null, 2));
+  logger.success(`updated package.json version to ${version}`);
+};
+
+const getPackageVersion = () => {
+  const fileFullPath = path.resolve(constants.WORKING_DIRECTORY, 'package.json');
+  if (!fs.existsSync(fileFullPath)) {
+    logger.error('package.json not found');
+    return;
+  }
+  const packageJson = JSON.parse(fs.readFileSync(fileFullPath, 'utf-8'));
+  return packageJson.version;
+};
+
+const getPackageSolutionVersion = (ignoreWarning: boolean = false) => {
+  const packageSolutionPath = path.resolve(constants.WORKING_DIRECTORY, 'config/package-solution.json');
+  if (!fs.existsSync(packageSolutionPath)) {
+    if (!ignoreWarning) logger.error('package-solution.json not found');
+    return;
+  }
+  const packageSolution = JSON.parse(fs.readFileSync(packageSolutionPath, 'utf-8'));
+  return packageSolution.solution.version;
+};
+
+export const listVersions = () => {
+  const jsonPackageV = getPackageVersion();
+  const sharepointVersion = getPackageSolutionVersion();
+
+  if (jsonPackageV === undefined || sharepointVersion === undefined) {
+    return;
+  }
+
+  logger.info(`package:    ${jsonPackageV}`);
+  logger.info(`sharepoint: ${sharepointVersion}`);
+  console.log();
+};
+
+export const syncVersion = () => {
+  const fileFullPath = path.resolve(constants.WORKING_DIRECTORY, 'package.json');
+  const packageJson = JSON.parse(fs.readFileSync(fileFullPath, 'utf-8'));
+  syncPackageSolution(packageJson.version);
+};
+
+const incPackageVersion = (version: string, part: 'major' | 'minor' | 'patch' = 'patch'): string => {
+  // Split the version string into parts
+  const versionParts = version.split('.').map(Number);
+
+  if (versionParts.length !== 3 || versionParts.some(isNaN)) {
+    throw new Error('Invalid version format. Expected format: "x.y.z"');
+  }
+
+  // Increment the specified part
+  switch (part) {
+    case 'major':
+      versionParts[0] += 1;
+      versionParts[1] = 0; // Reset minor and patch to 0
+      versionParts[2] = 0;
+      break;
+    case 'minor':
+      versionParts[1] += 1;
+      versionParts[2] = 0; // Reset patch to 0
+      break;
+    case 'patch':
+      versionParts[2] += 1;
+      break;
+  }
+
+  // Join the parts back into a string
+  return versionParts.join('.');
+};
+
+export const incrementVersion = (part: 'major' | 'minor' | 'patch') => {
+  const jsonPackageV = getPackageVersion();
+  const sharepointVersion = getPackageSolutionVersion(true);
+
+  if (jsonPackageV === undefined) {
+    return;
+  }
+
+  const pV = incPackageVersion(jsonPackageV, part);
+
+  updatePackage(pV);
+  if (sharepointVersion === undefined) {
+    return;
+  }
+
+  syncPackageSolution(pV);
+};

package/src/common/constants.ts

@@ -0,0 +1,4 @@
+import path from 'path';
+
+export const PACKAGE_DIRECTORY = path.resolve(__dirname, '..');
+export const WORKING_DIRECTORY = process.cwd();

package/src/common/index.ts

@@ -0,0 +1,4 @@
+import { logger } from './logger';
+import * as constants from './constants';
+import * as util from './util';
+export { logger, constants, util };

package/src/common/logger.ts

@@ -0,0 +1,45 @@
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import logSymbols from 'log-symbols';
+
+class Logger {
+  private logger: (...args: any[]) => void;
+
+  constructor() {
+    const args = process.argv.slice(2);
+    const silent = args.indexOf('--silent') !== -1;
+
+    if (silent) {
+      this.logger = () => 0;
+    } else {
+      this.logger = console.log;
+    }
+  }
+
+  public success(message: string) {
+    this.logger(logSymbols.success, chalk.green(message));
+    this.newLine();
+  }
+
+  public log(message: string) {
+    this.logger(message);
+  }
+
+  public warning(message: string) {
+    this.logger(logSymbols.warning, chalk.yellowBright(message));
+  }
+
+  public error(message: string) {
+    this.logger(logSymbols.error, chalk.redBright(message));
+  }
+
+  public info(message: string) {
+    this.logger(logSymbols.info, chalk.blueBright(message));
+  }
+
+  public newLine() {
+    this.logger('');
+  }
+}
+
+export const logger = new Logger();

package/src/common/util.ts

@@ -0,0 +1,55 @@
+import { promises as fsPromises } from 'fs';
+import os from 'os';
+import path from 'path';
+
+function getConfigPaths() {
+  const configDir = path.join(os.homedir(), '.spfx-toolkit');
+  const configPath = path.join(configDir, 'config.json');
+  return { configDir, configPath };
+}
+
+export async function checkIfFileExistsAsync(filename, includeError = true) {
+  try {
+    await fsPromises.readFile(filename, 'utf-8');
+    return true;
+  } catch (err) {
+    if (includeError) {
+      console.log(err);
+    }
+    return null;
+  }
+}
+
+export async function isUsingGulp(): Promise<boolean> {
+  const gulpFile = 'gulpfile.js';
+  return await checkIfFileExistsAsync(gulpFile, false);
+}
+
+export async function getScriptNameRunType(scriptName: string): Promise<any> {
+  const { configPath } = getConfigPaths();
+  try {
+    const data = await fsPromises.readFile(configPath, 'utf-8');
+    const config = JSON.parse(data);
+    if (config && typeof config === 'object' && scriptName in config) {
+      return config[scriptName];
+    }
+    return undefined;
+  } catch (err) {
+    // File does not exist or cannot be read
+    return undefined;
+  }
+}
+
+export async function addScriptNameRunType(scriptName: string, value: any): Promise<void> {
+  const { configDir, configPath } = getConfigPaths();
+  let config = {};
+  try {
+    const data = await fsPromises.readFile(configPath, 'utf-8');
+    config = JSON.parse(data);
+  } catch (err) {
+    // File does not exist or is invalid, start with empty config
+  }
+  config[scriptName] = value;
+  await fsPromises.mkdir(configDir, { recursive: true });
+  await fsPromises.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}

package/src/index.ts

@@ -0,0 +1,113 @@
+import chalk from 'chalk';
+import pkg from '../package.json';
+import * as commander from 'commander';
+import { Command } from 'commander';
+import * as commands from './commands';
+import { logger } from './common';
+const program = new Command();
+
+const defaultToolkitName = 'spfx-toolkit';
+
+program
+  .name('Matt Schauer SPFx Toolkit')
+  .description('CLI to help with SPFx development')
+  .addHelpText('beforeAll', chalk.blueBright('Developed by Matt Schauer'))
+  .version(pkg.version);
+
+program
+  .command('add-alias')
+  .description('add alias')
+  .addArgument(new commander.Argument('<name>', 'alias name to use for this program'))
+  .action((name) => {
+    commands.alias.addAlias(name, defaultToolkitName);
+  });
+
+program
+  .command('clear-alias')
+  .description('remove alias for spfx-toolkit')
+  .action(() => {
+    commands.alias.clearAlias(defaultToolkitName);
+  });
+
+program
+  .command('serve')
+  .description('Serve / Start the SPFx Project')
+  .action(() => {
+    commands.serve.run();
+  });
+
+program
+  .command('build')
+  .description('Build Project')
+  .option('-p, --usepackage', "Use package.json script 'build' as the command")
+  .option('-d, --isdefault', 'Set current command as default build action')
+  .action((options) => {
+    let usePackage = false;
+    let isdefault = false;
+    if (options.isdefault) {
+      isdefault = true;
+    }
+    if (options.usepackage) {
+      usePackage = true;
+    }
+
+    commands.build.run(usePackage, isdefault);
+  });
+
+program
+  .command('bundle')
+  .description('Bundle Project')
+  .option('-p, --usepackage', "Use package.json script 'bundle' as the command")
+  .option('-d, --isdefault', 'Set current command as default bundle action')
+  .action((options) => {
+    let usePackage = false;
+    let isdefault = false;
+    if (options.isdefault) {
+      isdefault = true;
+    }
+    if (options.usepackage) {
+      usePackage = true;
+    }
+
+    commands.bundle.run(usePackage, isdefault);
+  });
+
+program
+  .command('eslint')
+  .description('Backup and restore eslint file')
+  .option('-b, --backup', 'Backup the eslint file')
+  .option('-r, --restore', 'Restore from backup eslint file')
+  .action((options) => {
+    if (options.backup) {
+      commands.eslint.backupEslint();
+    } else if (options.restore) {
+      commands.eslint.restoreEslint();
+    } else {
+      logger.error('No action specified. Use --backup | -b <OR> --restore | -r');
+    }
+  });
+
+program
+  .command('version')
+  .option('-l, --list', 'List SPFx project versions')
+  .option('-s, --sync', 'Sync package.json version with package-solution.json version')
+  .option('-i, --increment <part>', 'Increment package version (major, minor, patch)', (value: string) => {
+    if (!['major', 'minor', 'patch'].includes(value)) {
+      throw new Error(`Invalid increment part: ${value}.  Must be one of major, minor, or patch.`);
+    }
+    return value; // Return the validated value
+  })
+  .action((options) => {
+    const { list, sync } = options;
+    if (list) {
+      commands.version.listVersions();
+    } else if (sync) {
+      commands.version.syncVersion();
+    } else if (options.increment) {
+      commands.version.incrementVersion(options.increment);
+    } else {
+      logger.error('No action specified. Use --list | -l OR --sync | -s OR --increment | -i');
+    }
+  });
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "outDir": "lib",
+    "baseUrl": ".",
+    "lib": ["dom", "ESNext"]
+  },
+  "exclude": ["node_modules", "tests"]
+}