@mschauer5/spfx-toolkit 1.0.27 → 1.0.28

package/src/commands/scripts.command.ts

@@ -1,139 +1,139 @@
-import { logger, util } from '../common';
-import spawn from 'cross-spawn';
-import { promises as fsPromises } from 'fs';
-import path from 'path';
-import { incrementVersion, syncVersion } from './version.command';
-
-function getProjectConfigPaths() {
-  const configDir = path.join(process.cwd());
-  const configPath = path.join(configDir, 'package.json');
-  return { configDir, configPath };
-}
-
-async function getScriptValue(scriptName: string, configPath: string): Promise<any> {
-  try {
-    const fileExists = await util.checkIfFileExistsAsync(configPath, false);
-    if (!fileExists) {
-      return undefined;
-    }
-
-    const isGulp = await util.isUsingGulp();
-    let suffix = ':heft';
-    if (isGulp) {
-      suffix = ':gulp';
-    }
-
-    const data = await fsPromises.readFile(configPath, 'utf-8');
-    const config = JSON.parse(data);
-    if (config && typeof config === 'object' && config.scripts) {
-      const scriptWithSuffix = scriptName + suffix;
-      const hasBase = scriptName in config.scripts;
-      const hasSuffix = scriptWithSuffix in config.scripts;
-      if (hasBase && hasSuffix) {
-        return config.scripts[scriptWithSuffix];
-      } else if (hasSuffix) {
-        return config.scripts[scriptWithSuffix];
-      } else if (hasBase) {
-        return config.scripts[scriptName];
-      }
-    }
-    return undefined;
-  } catch (err) {
-    // File does not exist or cannot be read
-    return undefined;
-  }
-}
-
-export async function getScriptByName(scriptName: string): Promise<string | undefined> {
-  const globalPath = util.getGlobalConfigPaths();
-  const localPath = getProjectConfigPaths();
-  let value = undefined;
-  value = await getScriptValue(scriptName, globalPath.configPath);
-
-  const localValue = await getScriptValue(scriptName, localPath.configPath);
-  if (localValue !== undefined) {
-    value = localValue;
-  }
-
-  return value;
-}
-
-export const run = async (scriptName: string, options?: any) => {
-  if (scriptName === 'bundle' && options && typeof options === 'string') {
-    if (options) {
-      incrementVersion(options as 'major' | 'minor' | 'patch');
-    } else {
-      syncVersion();
-    }
-  }
-
-  if (scriptName === 'serve') {
-    const envFilePath = path.join(process.cwd(), '.env');
-    const envFileExists = await util.checkIfFileExistsAsync(envFilePath, false);
-    if (envFileExists) {
-      const envContent = await fsPromises.readFile(envFilePath, 'utf-8');
-      const lines = envContent.split(/\r?\n/);
-      const envVars: { [key: string]: string } = {};
-      for (const line of lines) {
-        const [key, value] = line.split('=');
-        if (key && value) {
-          envVars[key.trim()] = value.trim();
-        }
-      }
-      if (envVars['tenantDomain']) {
-        process.env['SPFX_SERVE_TENANT_DOMAIN'] = envVars['tenantDomain'];
-      }
-    }
-  }
-
-  const value = await getScriptByName(scriptName);
-  if (!value) {
-    logger.error(`Script name '${scriptName}' not found in either local or global package.json!`);
-  } else {
-    try {
-      spawn.sync(value, { stdio: 'inherit', shell: true, cwd: process.cwd() });
-    } catch (error) {
-      logger.error(error);
-    }
-  }
-};
-
-export const sync = async (scriptName: string, to: 'global' | 'local') => {
-  const { configPath: globalConfigPath } = util.getGlobalConfigPaths();
-  const { configPath: localConfigPath } = getProjectConfigPaths();
-  let sourcePath = to === 'local' ? globalConfigPath : localConfigPath;
-
-  const scriptValue = await getScriptValue(scriptName, sourcePath);
-  if (!scriptValue) {
-    logger.error(`Source script name '${scriptName}' not found in the ${sourcePath}!`);
-    return;
-  }
-
-  const targetPath = to === 'local' ? localConfigPath : globalConfigPath;
-  const targetExists = await util.checkIfFileExistsAsync(targetPath, false);
-  if (!targetExists) {
-    logger.error(`Target package.json does not exist at path: ${targetPath}`);
-    return;
-  }
-  const data = await fsPromises.readFile(targetPath, 'utf-8');
-  const targetConfig = JSON.parse(data);
-  if (!targetConfig.scripts) {
-    targetConfig.scripts = {};
-  }
-
-  const isGulp = await util.isUsingGulp();
-  let suffix = ':heft';
-  const orgScriptName = scriptName;
-  if (isGulp) {
-    suffix = ':gulp';
-  }
-  if (to === 'global') {
-    scriptName = scriptName + suffix;
-  }
-
-  targetConfig.scripts[scriptName] = scriptValue;
-
-  await fsPromises.writeFile(targetPath, JSON.stringify(targetConfig, null, 2), 'utf-8');
-
-  logger.log(`Synchronized script '${orgScriptName}' to ${targetPath}`);
-};
+import { logger, util } from '../common';
+import spawn from 'cross-spawn';
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import { incrementVersion, syncVersion } from './version.command';
+
+function getProjectConfigPaths() {
+  const configDir = path.join(process.cwd());
+  const configPath = path.join(configDir, 'package.json');
+  return { configDir, configPath };
+}
+
+async function getScriptValue(scriptName: string, configPath: string): Promise<any> {
+  try {
+    const fileExists = await util.checkIfFileExistsAsync(configPath, false);
+    if (!fileExists) {
+      return undefined;
+    }
+
+    const isGulp = await util.isUsingGulp();
+    let suffix = ':heft';
+    if (isGulp) {
+      suffix = ':gulp';
+    }
+
+    const data = await fsPromises.readFile(configPath, 'utf-8');
+    const config = JSON.parse(data);
+    if (config && typeof config === 'object' && config.scripts) {
+      const scriptWithSuffix = scriptName + suffix;
+      const hasBase = scriptName in config.scripts;
+      const hasSuffix = scriptWithSuffix in config.scripts;
+      if (hasBase && hasSuffix) {
+        return config.scripts[scriptWithSuffix];
+      } else if (hasSuffix) {
+        return config.scripts[scriptWithSuffix];
+      } else if (hasBase) {
+        return config.scripts[scriptName];
+      }
+    }
+    return undefined;
+  } catch (err) {
+    // File does not exist or cannot be read
+    return undefined;
+  }
+}
+
+export async function getScriptByName(scriptName: string): Promise<string | undefined> {
+  const globalPath = util.getGlobalConfigPaths();
+  const localPath = getProjectConfigPaths();
+  let value = undefined;
+  value = await getScriptValue(scriptName, globalPath.configPath);
+
+  const localValue = await getScriptValue(scriptName, localPath.configPath);
+  if (localValue !== undefined) {
+    value = localValue;
+  }
+
+  return value;
+}
+
+export const run = async (scriptName: string, options?: any) => {
+  if (scriptName === 'bundle' && options && typeof options === 'string') {
+    if (options) {
+      incrementVersion(options as 'major' | 'minor' | 'patch');
+    } else {
+      syncVersion();
+    }
+  }
+
+  if (scriptName === 'serve') {
+    const envFilePath = path.join(process.cwd(), '.env');
+    const envFileExists = await util.checkIfFileExistsAsync(envFilePath, false);
+    if (envFileExists) {
+      const envContent = await fsPromises.readFile(envFilePath, 'utf-8');
+      const lines = envContent.split(/\r?\n/);
+      const envVars: { [key: string]: string } = {};
+      for (const line of lines) {
+        const [key, value] = line.split('=');
+        if (key && value) {
+          envVars[key.trim()] = value.trim();
+        }
+      }
+      if (envVars['tenantDomain']) {
+        process.env['SPFX_SERVE_TENANT_DOMAIN'] = envVars['tenantDomain'];
+      }
+    }
+  }
+
+  const value = await getScriptByName(scriptName);
+  if (!value) {
+    logger.error(`Script name '${scriptName}' not found in either local or global package.json!`);
+  } else {
+    try {
+      spawn.sync(value, { stdio: 'inherit', shell: true, cwd: process.cwd() });
+    } catch (error) {
+      logger.error(error);
+    }
+  }
+};
+
+export const sync = async (scriptName: string, to: 'global' | 'local') => {
+  const { configPath: globalConfigPath } = util.getGlobalConfigPaths();
+  const { configPath: localConfigPath } = getProjectConfigPaths();
+  let sourcePath = to === 'local' ? globalConfigPath : localConfigPath;
+
+  const scriptValue = await getScriptValue(scriptName, sourcePath);
+  if (!scriptValue) {
+    logger.error(`Source script name '${scriptName}' not found in the ${sourcePath}!`);
+    return;
+  }
+
+  const targetPath = to === 'local' ? localConfigPath : globalConfigPath;
+  const targetExists = await util.checkIfFileExistsAsync(targetPath, false);
+  if (!targetExists) {
+    logger.error(`Target package.json does not exist at path: ${targetPath}`);
+    return;
+  }
+  const data = await fsPromises.readFile(targetPath, 'utf-8');
+  const targetConfig = JSON.parse(data);
+  if (!targetConfig.scripts) {
+    targetConfig.scripts = {};
+  }
+
+  const isGulp = await util.isUsingGulp();
+  let suffix = ':heft';
+  const orgScriptName = scriptName;
+  if (isGulp) {
+    suffix = ':gulp';
+  }
+  if (to === 'global') {
+    scriptName = scriptName + suffix;
+  }
+
+  targetConfig.scripts[scriptName] = scriptValue;
+
+  await fsPromises.writeFile(targetPath, JSON.stringify(targetConfig, null, 2), 'utf-8');
+
+  logger.log(`Synchronized script '${orgScriptName}' to ${targetPath}`);
+};

package/src/common/index.ts

@@ -1,5 +1,5 @@
-import { logger } from './logger';
-import * as constants from './constants';
-import * as util from './util';
-// import * as settings from '../commands/settings';
-export { logger, constants, util };
+import { logger } from './logger';
+import * as constants from './constants';
+import * as util from './util';
+// import * as settings from '../commands/settings';
+export { logger, constants, util };

package/src/common/util.ts

@@ -1,113 +1,114 @@
-import { promises as fsPromises } from 'fs';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { logger } from './logger';
-
-export async function checkIfFileExistsAsync(filename, includeError = true) {
-  if (!fs.existsSync(filename)) {
-    if (includeError) {
-      logger.error(`No ${filename} found!`);
-    }
-    return false;
-  }
-
-  return true;
-}
-
-export function getGlobalConfigPaths() {
-  const configDir = path.join(os.homedir(), '.spfx-toolkit');
-  const configPath = path.join(configDir, 'package.json');
-
-  return { configDir, configPath };
-}
-
-export async function isUsingGulp(): Promise<boolean> {
-  const gulpFile = 'gulpfile.js';
-  return await checkIfFileExistsAsync(gulpFile, false);
-}
-
-export async function ensureGlobalPackageJsonExists() {
-  const { configDir, configPath } = getGlobalConfigPaths();
-  const exists = await checkIfFileExistsAsync(configPath, false);
-
-  if (!exists) {
-    // Create the directory if it doesn't exist and then create an empty package.json
-
-    await fsPromises.mkdir(configDir, { recursive: true });
-
-    await fsPromises.writeFile(configPath, JSON.stringify({ scripts: {} }, null, 2), 'utf-8');
-  }
-}
-
-export async function openGlobalPackageJsonInEditor() {
-  const { configPath } = getGlobalConfigPaths();
-  await ensureGlobalPackageJsonExists();
-
-  const spawn = require('child_process').spawn;
-  // Open the global package.json in VS Code
-  spawn(process.platform === 'win32' ? 'code.cmd' : 'code', [configPath], {
-    stdio: 'inherit',
-    shell: true
-  });
-}
-
-export async function initGlobalPackageJsonWithDefaults(force?: boolean) {
-  const { configPath } = getGlobalConfigPaths();
-  ensureGlobalPackageJsonExists();
-
-  const defaultScripts = {
-    'build:gulp': 'gulp build',
-    'build:heft': 'heft build',
-    'bundle:gulp': 'heft test --clean --production && heft package-solution --production',
-    'bundle:heft': 'heft build --clean && heft package',
-    'serve:heft': 'heft build-watch --serve',
-    'serve:gulp': 'gulp serve'
-  };
-
-  const defaultPackages = {
-    pnp: {
-      dependencies: ['@pnp/graph', '@pnp/core', '@pnp/odata', '@pnp/queryable', '@pnp/sp']
-    },
-    'react-query': {
-      dependencies: [
-        '@tanstack/react-query@4',
-        '@tanstack/query-async-storage-persister@4',
-        '@tanstack/query-persist-client-core@4',
-        '@tanstack/query-sync-storage-persister@5'
-      ],
-      devDependencies: ['@tanstack/react-query-devtools@4']
-    }
-  };
-
-  const packageJsonContent = await fsPromises.readFile(configPath, 'utf-8');
-  const packageJson = JSON.parse(packageJsonContent);
-
-  // Only add/overwrite scripts if force is true, otherwise do not overwrite existing matching scripts
-  packageJson.scripts = packageJson.scripts || {};
-  for (const [key, value] of Object.entries(defaultScripts)) {
-    if (force || !(key in packageJson.scripts)) {
-      packageJson.scripts[key] = value;
-    }
-  }
-
-  // packageJson.packages
-  packageJson.packages = packageJson.packages || {};
-  for (const [key, value] of Object.entries(defaultPackages)) {
-    if (force || !(key in packageJson.packages)) {
-      packageJson.packages[key] = value;
-    }
-  }
-
-  await fsPromises.writeFile(configPath, JSON.stringify(packageJson, null, 2), 'utf-8');
-  logger.success(`Global package.json initialized at ${configPath}`);
-}
-
-export const openVSCodeInDirectory = (directory: string) => {
-  const spawn = require('child_process').spawn;
-  // Open the selected directory in VS Code
-  spawn(process.platform === 'win32' ? 'code.cmd' : 'code', [directory], {
-    stdio: 'inherit',
-    shell: true
-  });
-};
+import { promises as fsPromises } from 'fs';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { logger } from './logger';
+
+export async function checkIfFileExistsAsync(filename: string, includeError = true) {
+  if (!fs.existsSync(filename)) {
+    if (includeError) {
+      logger.error(`No ${filename} found!`);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+export function getGlobalConfigPaths() {
+  const configDir = path.join(os.homedir(), '.spfx-toolkit');
+  const configPath = path.join(configDir, 'package.json');
+
+  return { configDir, configPath };
+}
+
+export async function isUsingGulp(): Promise<boolean> {
+  const gulpFile = 'gulpfile.js';
+  return await checkIfFileExistsAsync(gulpFile, false);
+}
+
+export async function ensureGlobalPackageJsonExists() {
+  const { configDir, configPath } = getGlobalConfigPaths();
+  const exists = await checkIfFileExistsAsync(configPath, false);
+
+  if (!exists) {
+    logger.info('Global package.json for spfx-toolkit not found. Creating one...');
+    // Create the directory if it doesn't exist and then create an empty package.json
+
+    await fsPromises.mkdir(configDir, { recursive: true });
+
+    await fsPromises.writeFile(configPath, JSON.stringify({ scripts: {} }, null, 2), 'utf-8');
+  }
+}
+
+export async function openGlobalPackageJsonInEditor() {
+  const { configPath } = getGlobalConfigPaths();
+  await ensureGlobalPackageJsonExists();
+
+  const spawn = require('child_process').spawn;
+  // Open the global package.json in VS Code
+  spawn(process.platform === 'win32' ? 'code.cmd' : 'code', [configPath], {
+    stdio: 'inherit',
+    shell: true
+  });
+}
+
+export async function initGlobalPackageJsonWithDefaults(force?: boolean) {
+  const { configPath } = getGlobalConfigPaths();
+  await ensureGlobalPackageJsonExists();
+
+  const defaultScripts = {
+    'build:gulp': 'gulp build',
+    'build:heft': 'heft build',
+    'bundle:gulp': 'heft test --clean --production && heft package-solution --production',
+    'bundle:heft': 'heft build --clean && heft package',
+    'serve:heft': 'heft build-watch --serve',
+    'serve:gulp': 'gulp serve'
+  };
+
+  const defaultPackages = {
+    pnp: {
+      dependencies: ['@pnp/graph', '@pnp/core', '@pnp/odata', '@pnp/queryable', '@pnp/sp']
+    },
+    'react-query': {
+      dependencies: [
+        '@tanstack/react-query@4',
+        '@tanstack/query-async-storage-persister@4',
+        '@tanstack/query-persist-client-core@4',
+        '@tanstack/query-sync-storage-persister@5'
+      ],
+      devDependencies: ['@tanstack/react-query-devtools@4']
+    }
+  };
+
+  const packageJsonContent = await fsPromises.readFile(configPath, 'utf-8');
+  const packageJson = JSON.parse(packageJsonContent);
+
+  // Only add/overwrite scripts if force is true, otherwise do not overwrite existing matching scripts
+  packageJson.scripts = packageJson.scripts || {};
+  for (const [key, value] of Object.entries(defaultScripts)) {
+    if (force || !(key in packageJson.scripts)) {
+      packageJson.scripts[key] = value;
+    }
+  }
+
+  // packageJson.packages
+  packageJson.packages = packageJson.packages || {};
+  for (const [key, value] of Object.entries(defaultPackages)) {
+    if (force || !(key in packageJson.packages)) {
+      packageJson.packages[key] = value;
+    }
+  }
+
+  await fsPromises.writeFile(configPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+  logger.success(`Global package.json initialized at ${configPath}`);
+}
+
+export const openVSCodeInDirectory = (directory: string) => {
+  const spawn = require('child_process').spawn;
+  // Open the selected directory in VS Code
+  spawn(process.platform === 'win32' ? 'code.cmd' : 'code', [directory], {
+    stdio: 'inherit',
+    shell: true
+  });
+};