@proteinjs/build 1.3.0 → 1.4.0

package/src/versionWorkspace.ts

@@ -1,14 +1,14 @@
-import * as path from 'path'
-import { exec } from 'child_process'
-import { LocalPackage, LocalPackageMap, PackageUtil, cmd, Fs, LogColorWrapper } from '@proteinjs/util-node'
-import { Logger } from '@proteinjs/util'
-import semver from 'semver'
-import { Commit } from './Github'
-import { primaryLogColor, secondaryLogColor } from './logColors'
+import * as path from 'path';
+import { exec } from 'child_process';
+import { LocalPackage, LocalPackageMap, PackageUtil, cmd, Fs, LogColorWrapper } from '@proteinjs/util-node';
+import { Logger } from '@proteinjs/util';
+import semver from 'semver';
+import { Commit } from './Github';
+import { primaryLogColor, secondaryLogColor } from './logColors';
 
 const cw = new LogColorWrapper();
 const logger = new Logger(cw.color('workspace:', primaryLogColor) + cw.color('version', secondaryLogColor));
-const fixedVersionWorkspacesToVersion: {[workspacePath: string]: boolean} = {};
+const fixedVersionWorkspacesToVersion: { [workspacePath: string]: boolean } = {};
 
 export async function versionWorkspace() {
   // fail fast if npm token is not available
@@ -16,33 +16,41 @@ export async function versionWorkspace() {
 
   const workspacePath = process.cwd();
   await pullWorkspace(workspacePath);
-  const { packageMap, packageGraph, sortedPackageNames, workspaceToPackageMap } = await PackageUtil.getWorkspaceMetadata(workspacePath);
+  const { packageMap, packageGraph, sortedPackageNames, workspaceToPackageMap } =
+    await PackageUtil.getWorkspaceMetadata(workspacePath);
   const skippedPackages = ['root', 'typescript-parser'];
-  const filteredPackageNames = sortedPackageNames.filter(packageName => {
+  const filteredPackageNames = sortedPackageNames.filter((packageName) => {
     const localPackage = packageMap[packageName];
-    return !!localPackage.packageJson.scripts?.clean
-      && !!localPackage.packageJson.scripts?.build 
-      && !skippedPackages.includes(packageName)
-    ;
+    return (
+      !!localPackage.packageJson.scripts?.clean &&
+      !!localPackage.packageJson.scripts?.build &&
+      !skippedPackages.includes(packageName)
+    );
   });
 
   logger.info(`> Versioning workspace (${workspacePath})`);
-  for (let packageName of filteredPackageNames) {
+  for (const packageName of filteredPackageNames) {
     const localPackage = packageMap[packageName];
     const dependenciesChanged = await bumpDependencies(localPackage, packageMap, packageGraph);
-    if (!dependenciesChanged)
+    if (!dependenciesChanged) {
       continue;
+    }
 
     await buildAndTest(localPackage);
-    if (localPackage.workspace?.lernaJson?.version === 'fixed') {
+    if (
+      localPackage.workspace &&
+      localPackage.workspace.lernaJson &&
+      localPackage.workspace.lernaJson.version !== 'independent'
+    ) {
       fixedVersionWorkspacesToVersion[localPackage.workspace.path] = true;
       logger.info(`(${cw.color(packageName)}) skipping version push for package in a fixed-version workspace`);
       continue;
     }
 
     await pushAndTag(localPackage);
-    if (!localPackage.packageJson.private && localPackage.packageJson.publishConfig?.access === 'public')
+    if (!localPackage.packageJson.private && localPackage.packageJson.publishConfig?.access === 'public') {
       await publish(localPackage);
+    }
   }
 
   await syncFixedVersionWorkspaces(Object.keys(fixedVersionWorkspacesToVersion), packageMap, workspaceToPackageMap);
@@ -53,16 +61,17 @@ export async function versionWorkspace() {
 
 async function pullWorkspace(workspacePath: string) {
   const { packageMap, sortedPackageNames } = await PackageUtil.getWorkspaceMetadata(workspacePath);
-  const filteredPackageNames = sortedPackageNames.filter(packageName => {
+  const filteredPackageNames = sortedPackageNames.filter((packageName) => {
     const localPackage = packageMap[packageName];
-    return !!localPackage.packageJson.scripts?.clean
-      && !!localPackage.packageJson.scripts?.build 
-      && packageName != 'typescript-parser'
-    ;
+    return (
+      !!localPackage.packageJson.scripts?.clean &&
+      !!localPackage.packageJson.scripts?.build &&
+      packageName != 'typescript-parser'
+    );
   });
 
   logger.info(`> Pulling workspace (${workspacePath})`);
-  for (let packageName of filteredPackageNames) {
+  for (const packageName of filteredPackageNames) {
     const localPackage = packageMap[packageName];
     await pull(localPackage);
   }
@@ -72,24 +81,33 @@ async function pullWorkspace(workspacePath: string) {
 
 async function bumpDependencies(localPackage: LocalPackage, packageMap: LocalPackageMap, packageGraph: any) {
   const localDependencies = packageGraph.successors(localPackage.name);
-  if (!localDependencies || localDependencies.length == 0)
+  if (!localDependencies || localDependencies.length == 0) {
     return false;
+  }
 
   let dependenciesChanged = false;
-  for (let localDependency of localDependencies) {
+  for (const localDependency of localDependencies) {
     const localDependencyPackage = packageMap[localDependency];
     const localDependencyVersion = localDependencyPackage.packageJson.version as string;
     const currentDependencyVersion = getDependencyVersion(localDependency, localPackage);
-    if (!currentDependencyVersion)
-      throw new Error(`Package (${cw.color(localPackage.name)}) has dependency on ${localDependency}, but cannot find version in ${cw.color(localPackage.name)}'s package.json`);
+    if (!currentDependencyVersion) {
+      throw new Error(
+        `Package (${cw.color(localPackage.name)}) has dependency on ${localDependency}, but cannot find version in ${cw.color(localPackage.name)}'s package.json`
+      );
+    }
 
-    if (currentDependencyVersion.isLocalPath)
+    if (currentDependencyVersion.isLocalPath) {
       continue;
+    }
 
-    if (currentDependencyVersion?.version == localDependencyVersion)
+    if (currentDependencyVersion?.version == localDependencyVersion) {
       continue;
+    }
 
-    const newDependencyVersion: DependencyVersion = { prefix: currentDependencyVersion.prefix, version: localDependencyVersion };
+    const newDependencyVersion: DependencyVersion = {
+      prefix: currentDependencyVersion.prefix,
+      version: localDependencyVersion,
+    };
     setDependencyVersion(localDependency, currentDependencyVersion, newDependencyVersion, localPackage);
     dependenciesChanged = true;
   }
@@ -97,57 +115,85 @@ async function bumpDependencies(localPackage: LocalPackage, packageMap: LocalPac
   if (dependenciesChanged) {
     const currentVersion = localPackage.packageJson.version;
     localPackage.packageJson.version = semver.inc(currentVersion, 'patch');
-    logger.info(`(${cw.color(localPackage.name)}) bumping version from ${currentVersion} -> ${localPackage.packageJson.version}`);
+    logger.info(
+      `(${cw.color(localPackage.name)}) bumping version from ${currentVersion} -> ${localPackage.packageJson.version}`
+    );
     await Fs.writeFiles([{ path: localPackage.filePath, content: JSON.stringify(localPackage.packageJson, null, 2) }]);
   }
 
   return dependenciesChanged;
 }
 
-type DependencyVersion = { prefix?: string, version: string, isLocalPath?: boolean }
-
-function getDependencyVersion(dependencyPackageName: string, localPackage: LocalPackage): DependencyVersion|undefined {
-  let currentRawDependencyVersion = localPackage.packageJson.dependencies ? localPackage.packageJson.dependencies[dependencyPackageName] : undefined;
-  if (!currentRawDependencyVersion)
-    currentRawDependencyVersion = localPackage.packageJson.devDependencies ? localPackage.packageJson.devDependencies[dependencyPackageName] : undefined;
+type DependencyVersion = { prefix?: string; version: string; isLocalPath?: boolean };
+
+function getDependencyVersion(
+  dependencyPackageName: string,
+  localPackage: LocalPackage
+): DependencyVersion | undefined {
+  let currentRawDependencyVersion = localPackage.packageJson.dependencies
+    ? localPackage.packageJson.dependencies[dependencyPackageName]
+    : undefined;
+  if (!currentRawDependencyVersion) {
+    currentRawDependencyVersion = localPackage.packageJson.devDependencies
+      ? localPackage.packageJson.devDependencies[dependencyPackageName]
+      : undefined;
+  }
 
-  if (!currentRawDependencyVersion)
+  if (!currentRawDependencyVersion) {
     return undefined;
+  }
 
-  if (currentRawDependencyVersion.startsWith('file:') || currentRawDependencyVersion.startsWith('.'))
+  if (currentRawDependencyVersion.startsWith('file:') || currentRawDependencyVersion.startsWith('.')) {
     return { version: currentRawDependencyVersion, isLocalPath: true };
+  }
 
   const match = currentRawDependencyVersion.match(/^([~^]?)(\d+\.\d+\.\d+)/);
   return { prefix: match[1], version: match[2] };
 }
 
-function setDependencyVersion(dependencyPackageName: string, currentVersion: DependencyVersion, newVersion: DependencyVersion, localPackage: LocalPackage) {
+function setDependencyVersion(
+  dependencyPackageName: string,
+  currentVersion: DependencyVersion,
+  newVersion: DependencyVersion,
+  localPackage: LocalPackage
+) {
   const newRawVersion = newVersion.prefix ? newVersion.prefix + newVersion.version : newVersion.version;
-  if (localPackage.packageJson.dependencies && localPackage.packageJson.dependencies[dependencyPackageName])
+  if (localPackage.packageJson.dependencies && localPackage.packageJson.dependencies[dependencyPackageName]) {
     localPackage.packageJson.dependencies[dependencyPackageName] = newRawVersion;
-  else
+  } else {
     localPackage.packageJson.devDependencies[dependencyPackageName] = newRawVersion;
+  }
 
-  const currentRawVersion = currentVersion.prefix ? currentVersion.prefix + currentVersion.version : currentVersion.version;
-  logger.info(`(${cw.color(localPackage.name)}) updating dependency version of ${cw.color(dependencyPackageName)} (${currentRawVersion} -> ${newRawVersion})`);
+  const currentRawVersion = currentVersion.prefix
+    ? currentVersion.prefix + currentVersion.version
+    : currentVersion.version;
+  logger.info(
+    `(${cw.color(localPackage.name)}) updating dependency version of ${cw.color(dependencyPackageName)} (${currentRawVersion} -> ${newRawVersion})`
+  );
 }
 
-async function syncFixedVersionWorkspaces(fixedVersionWorkspacePaths: string[], packageMap: LocalPackageMap, workspaceToPackageMap: {[workspacePath: string]: string[]}) {
-  if (fixedVersionWorkspacePaths.length == 0)
+async function syncFixedVersionWorkspaces(
+  fixedVersionWorkspacePaths: string[],
+  packageMap: LocalPackageMap,
+  workspaceToPackageMap: { [workspacePath: string]: string[] }
+) {
+  if (fixedVersionWorkspacePaths.length == 0) {
     return;
+  }
 
   logger.info(`> Syncing fixed-version workspaces`);
-  for (let workspacePath of fixedVersionWorkspacePaths) {
+  for (const workspacePath of fixedVersionWorkspacePaths) {
     const workspacePackages = workspaceToPackageMap[workspacePath]
-      .filter(packageName => packageName != 'typescript-parser')
-      .map(packageName => packageMap[packageName])
-    ;
-    if (workspacePackages.length == 0)
+      .filter((packageName) => packageName != 'typescript-parser')
+      .map((packageName) => packageMap[packageName]);
+    if (workspacePackages.length == 0) {
       continue;
+    }
 
-    const syncedVersion = await syncFixedVersions(workspacePackages);
-    if (!syncedVersion)
+    const syncedVersion = await syncFixedVersions(workspacePath, workspacePackages);
+    if (!syncedVersion) {
       continue;
+    }
 
     await pushAndTagFixedVersionRepo(workspacePath, syncedVersion);
   }
@@ -155,33 +201,49 @@ async function syncFixedVersionWorkspaces(fixedVersionWorkspacePaths: string[],
   logger.info(`> Synced fixed-version workspaces`);
 }
 
-async function syncFixedVersions(localPackages: LocalPackage[]): Promise<string|false> {
-  let highestVersion: string|undefined;
-  for (let localPackage of localPackages) {
+async function syncFixedVersions(workspacePath: string, localPackages: LocalPackage[]): Promise<string | false> {
+  let highestVersion: string | undefined;
+  for (const localPackage of localPackages) {
     if (!highestVersion) {
       highestVersion = localPackage.packageJson.version;
       continue;
     }
 
-    if (semver.gt(localPackage.packageJson.version, highestVersion))
+    if (semver.gt(localPackage.packageJson.version, highestVersion)) {
       highestVersion = localPackage.packageJson.version;
+    }
   }
 
-  if (!highestVersion)
+  if (!highestVersion) {
     throw new Error(`Unable to find version for packages`);
+  }
 
   let syncedFixedVersions = false;
-  for (let localPackage of localPackages) {
+  for (const localPackage of localPackages) {
     const currentVersion = localPackage.packageJson.version;
-    if (currentVersion === highestVersion)
+    if (currentVersion === highestVersion) {
       continue;
+    }
 
     localPackage.packageJson.version = highestVersion;
-    logger.info(`(${cw.color(localPackage.name)}) bumping version from ${currentVersion} -> ${localPackage.packageJson.version}`);
+    logger.info(
+      `(${cw.color(localPackage.name)}) bumping version from ${currentVersion} -> ${localPackage.packageJson.version}`
+    );
     await Fs.writeFiles([{ path: localPackage.filePath, content: JSON.stringify(localPackage.packageJson, null, 2) }]);
     syncedFixedVersions = true;
   }
 
+  if (syncedFixedVersions) {
+    const lernaJson = localPackages[0].workspace?.lernaJson;
+    if (!lernaJson) {
+      throw new Error(`Cannot find lerna.json for workspace: ${workspacePath}`);
+    }
+
+    const lernaJsonPath = path.join(workspacePath, 'lerna.json');
+    lernaJson.version = highestVersion;
+    await Fs.writeFiles([{ path: lernaJsonPath, content: JSON.stringify(lernaJson, null, 2) }]);
+  }
+
   return syncedFixedVersions ? highestVersion : false;
 }
 
@@ -214,7 +276,12 @@ async function pushAndTag(localPackage: LocalPackage): Promise<Commit> {
   const packageDir = path.dirname(localPackage.filePath);
   logger.info(`(${cw.color(localPackage.name)}) pushing latest version (${localPackage.packageJson.version})`);
   await cmd('git', ['add', '.'], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
-  await cmd('git', ['commit', '-m', `chore(version): bumping dependency versions for ${localPackage.name} [skip ci]`], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
+  await cmd(
+    'git',
+    ['commit', '-m', `chore(version): bumping dependency versions for ${localPackage.name} [skip ci]`],
+    { cwd: packageDir },
+    { logPrefix: `[${cw.color(localPackage.name)}] ` }
+  );
   await cmd('git', ['push'], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
   logger.info(`(${cw.color(localPackage.name)}) pushed latest version (${localPackage.packageJson.version})`);
   const latestCommitSha = await getLatestCommitSha(packageDir);
@@ -222,8 +289,18 @@ async function pushAndTag(localPackage: LocalPackage): Promise<Commit> {
   const commit = { sha: latestCommitSha, ...repoInfo };
   const tagName = `${localPackage.name}@${localPackage.packageJson.version}`;
   logger.info(`(${cw.color(localPackage.name)}) pushing tag (${tagName})`);
-  await cmd('git', ['tag', '-a', tagName, '-m', `Release ${tagName}`], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
-  await cmd('git', ['push', 'origin', tagName], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
+  await cmd(
+    'git',
+    ['tag', '-a', tagName, '-m', `Release ${tagName}`],
+    { cwd: packageDir },
+    { logPrefix: `[${cw.color(localPackage.name)}] ` }
+  );
+  await cmd(
+    'git',
+    ['push', 'origin', tagName],
+    { cwd: packageDir },
+    { logPrefix: `[${cw.color(localPackage.name)}] ` }
+  );
   logger.info(`(${cw.color(localPackage.name)}) pushed tag (${tagName})`);
   return commit;
 }
@@ -232,7 +309,12 @@ async function pushAndTagFixedVersionRepo(dir: string, version: string): Promise
   const repoName = path.basename(dir.endsWith(path.sep) ? dir.slice(0, -1) : dir);
   logger.info(`(${cw.color(repoName)}) pushing latest version (${version})`);
   await cmd('git', ['add', '.'], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
-  await cmd('git', ['commit', '-m', `chore(version): bumping dependency versions [skip ci]`], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
+  await cmd(
+    'git',
+    ['commit', '-m', `chore(version): bumping dependency versions [skip ci]`],
+    { cwd: dir },
+    { logPrefix: `[${cw.color(repoName)}] ` }
+  );
   await cmd('git', ['push'], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
   logger.info(`(${cw.color(repoName)}) pushed latest version (${version})`);
   const latestCommitSha = await getLatestCommitSha(dir);
@@ -240,7 +322,12 @@ async function pushAndTagFixedVersionRepo(dir: string, version: string): Promise
   const commit = { sha: latestCommitSha, ...repoInfo };
   const tagName = `v${version}`;
   logger.info(`(${cw.color(repoName)}) pushing tag (${tagName})`);
-  await cmd('git', ['tag', '-a', tagName, '-m', `Release ${tagName}`], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
+  await cmd(
+    'git',
+    ['tag', '-a', tagName, '-m', `Release ${tagName}`],
+    { cwd: dir },
+    { logPrefix: `[${cw.color(repoName)}] ` }
+  );
   await cmd('git', ['push', 'origin', tagName], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
   logger.info(`(${cw.color(repoName)}) pushed tag (${tagName})`);
   return commit;
@@ -248,18 +335,23 @@ async function pushAndTagFixedVersionRepo(dir: string, version: string): Promise
 
 async function pushMetarepos(dir: string) {
   const metarepoPaths = (await Fs.getFilePathsMatchingGlob(dir, '**/.gitmodules', ['**/node_modules/**', '**/dist/**']))
-    .map(gitmodulesPath => path.dirname(gitmodulesPath))
-    .sort((a, b) => b.localeCompare(a))
-  ;
-  for (let metarepoPath of metarepoPaths)
+    .map((gitmodulesPath) => path.dirname(gitmodulesPath))
+    .sort((a, b) => b.localeCompare(a));
+  for (const metarepoPath of metarepoPaths) {
     await pushMetarepo(metarepoPath);
+  }
 }
 
 async function pushMetarepo(dir: string) {
   const repoName = path.basename(dir.endsWith(path.sep) ? dir.slice(0, -1) : dir);
   logger.info(`(${cw.color(repoName)}) pushing metarepo (${dir})`);
   await cmd('git', ['add', '.'], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
-  await cmd('git', ['commit', '-m', `chore(version): bumping submodule versions [skip ci]`], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
+  await cmd(
+    'git',
+    ['commit', '-m', `chore(version): bumping submodule versions [skip ci]`],
+    { cwd: dir },
+    { logPrefix: `[${cw.color(repoName)}] ` }
+  );
   await cmd('git', ['pull'], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
   await cmd('git', ['push'], { cwd: dir }, { logPrefix: `[${cw.color(repoName)}] ` });
   logger.info(`(${cw.color(repoName)}) pushed metarepo (${dir})`);
@@ -267,7 +359,7 @@ async function pushMetarepo(dir: string) {
 
 async function symlinkWorkspace(workspacePath: string, packageNames: string[], packageMap: LocalPackageMap) {
   logger.info(`> Symlinking local dependencies in workspace (${workspacePath})`);
-  for (let packageName of packageNames) {
+  for (const packageName of packageNames) {
     const localPackage = packageMap[packageName];
     await PackageUtil.symlinkDependencies(localPackage, packageMap, logger);
   }
@@ -285,7 +377,7 @@ async function getLatestCommitSha(dir: string): Promise<string> {
       resolve(stdout.trim());
     });
   });
-};
+}
 
 type RepoInfo = {
   owner: string;
@@ -303,6 +395,7 @@ async function getRepoInfo(dir: string): Promise<RepoInfo> {
       const lines = stdout.split('\n');
       for (const line of lines) {
         if (line.startsWith('origin')) {
+          // eslint-disable-next-line no-useless-escape
           const match = line.match(/github\.com[:\/](.+?)\/(.+?)\.git/);
           if (match) {
             const [_, owner, repo] = match;
@@ -315,7 +408,7 @@ async function getRepoInfo(dir: string): Promise<RepoInfo> {
       reject(new Error('Origin remote not found or is not a GitHub repository'));
     });
   });
-};
+}
 
 async function publish(localPackage: LocalPackage) {
   if (localPackage.packageJson.private) {
@@ -330,14 +423,25 @@ async function publish(localPackage: LocalPackage) {
 
   const packageDir = path.dirname(localPackage.filePath);
   logger.info(`(${cw.color(localPackage.name)}) publishing latest version (${localPackage.packageJson.version})`);
-  await cmd('npm', ['set', `//registry.npmjs.org/:_authToken=${getNpmToken()}`], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
-  await cmd('npm', ['publish', '--tag', 'latest', '--access', 'public'], { cwd: packageDir }, { logPrefix: `[${cw.color(localPackage.name)}] ` });
+  await cmd(
+    'npm',
+    ['set', `//registry.npmjs.org/:_authToken=${getNpmToken()}`],
+    { cwd: packageDir },
+    { logPrefix: `[${cw.color(localPackage.name)}] ` }
+  );
+  await cmd(
+    'npm',
+    ['publish', '--tag', 'latest', '--access', 'public'],
+    { cwd: packageDir },
+    { logPrefix: `[${cw.color(localPackage.name)}] ` }
+  );
   logger.info(`(${cw.color(localPackage.name)}) published latest version (${localPackage.packageJson.version})`);
 }
 
 function getNpmToken() {
-  if (process.env.NPM_TOKEN)
+  if (process.env.NPM_TOKEN) {
     return process.env.NPM_TOKEN;
+  }
 
   throw new Error(`NPM_TOKEN env variable not set`);
-}
+}

package/src/watchWorkspace.ts

@@ -1,35 +1,45 @@
-import * as path from 'path'
-import { PackageUtil, WorkspaceMetadata, cmd, LogColorWrapper } from '@proteinjs/util-node'
-import { Logger } from '@proteinjs/util'
+import * as path from 'path';
+import { PackageUtil, WorkspaceMetadata, cmd, LogColorWrapper } from '@proteinjs/util-node';
+import { Logger } from '@proteinjs/util';
 import { primaryLogColor, secondaryLogColor } from './logColors';
 
 export const watchWorkspace = async (workspaceMetadata?: WorkspaceMetadata) => {
   const cw = new LogColorWrapper();
   const logger = new Logger(cw.color('workspace:', primaryLogColor) + cw.color('watch', secondaryLogColor));
   const workspacePath = process.cwd();
-  const { packageMap, sortedPackageNames } = workspaceMetadata ? workspaceMetadata : await PackageUtil.getWorkspaceMetadata(workspacePath);
+  const { packageMap, sortedPackageNames } = workspaceMetadata
+    ? workspaceMetadata
+    : await PackageUtil.getWorkspaceMetadata(workspacePath);
   const skippedPackages = ['root'];
-  const filteredPackageNames = sortedPackageNames.filter(packageName => !!packageMap[packageName].packageJson.scripts?.watch && !skippedPackages.includes(packageName));
+  const filteredPackageNames = sortedPackageNames.filter(
+    (packageName) => !!packageMap[packageName].packageJson.scripts?.watch && !skippedPackages.includes(packageName)
+  );
 
-  logger.info(`> Watching ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
+  logger.info(
+    `> Watching ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`
+  );
   const loggingStartDelay = 0;
-  for (let packageName of filteredPackageNames) {
+  for (const packageName of filteredPackageNames) {
     const localPackage = packageMap[packageName];
     const packageDir = path.dirname(localPackage.filePath);
     const loggingEnabledState = { loggingEnabled: false };
-    setTimeout(() => loggingEnabledState.loggingEnabled = true, loggingStartDelay);
+    setTimeout(() => (loggingEnabledState.loggingEnabled = true), loggingStartDelay);
     const logPrefix = `[${cw.color(packageName)}] `;
     let inMultiLineLog = false;
     const stdoutFilter = (log: string) => {
-      if (log.includes('File change detected. Starting incremental compilation'))
+      if (log.includes('File change detected. Starting incremental compilation')) {
         return;
-  
+      }
+
+      // eslint-disable-next-line no-control-regex
       let filteredOutput = log.replace(/\x1Bc|\x1B\[2J\x1B\[0;0H/g, ''); // char sequence for clearing terminal
-      if (filteredOutput.includes('Watching for file changes.'))
+      if (filteredOutput.includes('Watching for file changes.')) {
         filteredOutput = filteredOutput.replace(/^\n/, '');
+      }
 
-      if (filteredOutput.trim() == '')
+      if (filteredOutput.trim() == '') {
         return;
+      }
 
       // Replace newline with newline+prefix under the following conditions:
       // 1. It is not at the start of the string (?<!^)
@@ -37,22 +47,29 @@ export const watchWorkspace = async (workspaceMetadata?: WorkspaceMetadata) => {
       // 3. It is not followed by another newline (?!\r?\n)
       filteredOutput = filteredOutput.replace(/(?<!^)(\r?\n)(?!\r?\n|$)/g, `$1${logPrefix}`);
 
-      if (!inMultiLineLog)
+      if (!inMultiLineLog) {
         filteredOutput = `${logPrefix}${filteredOutput}`;
+      }
 
-      if (filteredOutput.endsWith('\n') || filteredOutput.endsWith('\r\n'))
+      if (filteredOutput.endsWith('\n') || filteredOutput.endsWith('\r\n')) {
         inMultiLineLog = false;
-      else
+      } else {
         inMultiLineLog = true;
-  
+      }
+
       return filteredOutput;
     };
-    cmd('npm', ['run', 'watch'], { cwd: packageDir }, { 
-      omitLogs: { 
-        stdout: {
-          filter: stdoutFilter,
-        }
-      }, 
-    });
+    cmd(
+      'npm',
+      ['run', 'watch'],
+      { cwd: packageDir },
+      {
+        omitLogs: {
+          stdout: {
+            filter: stdoutFilter,
+          },
+        },
+      }
+    );
   }
-}
+};

package/src/workspaceCommand.ts

@@ -1,56 +1,62 @@
-import * as path from 'path'
-import { LocalPackageMap, LogColorWrapper, PackageUtil, cmd, parseArgsMap } from '@proteinjs/util-node'
-import { Logger } from '@proteinjs/util'
-import { primaryLogColor, secondaryLogColor } from './logColors'
+import * as path from 'path';
+import { LocalPackageMap, LogColorWrapper, PackageUtil, cmd, parseArgsMap } from '@proteinjs/util-node';
+import { Logger } from '@proteinjs/util';
+import { primaryLogColor, secondaryLogColor } from './logColors';
 
 /**
  * Run a npm command against all packages in the workspace, in dependency order.
- * 
+ *
  * ie: `npx workspace test --skip=@some/package,@another/package`
- * 
+ *
  * Optional args:
- * 
+ *
  * --skip=@some/package,@another/package
  */
 export const workspaceCommand = async () => {
-  const command = process.argv[2]
+  const command = process.argv[2];
   const cw = new LogColorWrapper();
   const logger = new Logger(cw.color('workspace:', primaryLogColor) + cw.color(command, secondaryLogColor));
   const args = getArgs();
   const workspacePath = process.cwd();
   const { packageMap, sortedPackageNames } = await PackageUtil.getWorkspaceMetadata(workspacePath);
   const skippedPackages = ['root'];
-  const filteredPackageNames = sortedPackageNames.filter(packageName => { 
-    return hasScript(command, packageName, packageMap) &&
+  const filteredPackageNames = sortedPackageNames.filter((packageName) => {
+    return (
+      hasScript(command, packageName, packageMap) &&
       !(args.skip && args.skip.includes(packageName)) &&
       !skippedPackages.includes(packageName)
-    ;
+    );
   });
   if (filteredPackageNames.length == 0) {
     logger.info(`> There are no packages with the \`${command}\` script in workspace (${workspacePath})`);
     return;
   }
 
-  logger.info(`> Running \`npm run ${command}\` for ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
-  for (let packageName of filteredPackageNames) {
+  logger.info(
+    `> Running \`npm run ${command}\` for ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`
+  );
+  for (const packageName of filteredPackageNames) {
     const localPackage = packageMap[packageName];
     const packageDir = path.dirname(localPackage.filePath);
     await cmd('npm', ['run', command], { cwd: packageDir }, { logPrefix: `[${cw.color(packageName)}] ` });
   }
-  logger.info(`> Ran \`npm run ${command}\` for ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
-}
+  logger.info(
+    `> Ran \`npm run ${command}\` for ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`
+  );
+};
 
 type Args = {
-  skip?: string[],
-}
+  skip?: string[];
+};
 
 function getArgs() {
   const args: Args = {};
   const argsMap = parseArgsMap(process.argv.slice(3));
-  for (let argName in argsMap) {
+  for (const argName in argsMap) {
     const argValue = argsMap[argName];
-    if (argName == 'skip' && typeof argValue === 'string')
+    if (argName == 'skip' && typeof argValue === 'string') {
       args.skip = argValue.split(',');
+    }
   }
 
   return args;
@@ -58,4 +64,4 @@ function getArgs() {
 
 function hasScript(scriptName: string, packageName: string, packageMap: LocalPackageMap) {
   return !!packageMap[packageName].packageJson.scripts && !!packageMap[packageName].packageJson.scripts[scriptName];
-}
+}