@proteinjs/build 1.3.1 → 1.4.0

package/src/symlinkWorkspace.ts

@@ -1,14 +1,14 @@
-import { LogColorWrapper, PackageUtil, parseArgsMap } from '@proteinjs/util-node'
-import { Logger } from '@proteinjs/util'
-import { primaryLogColor, secondaryLogColor } from './logColors'
+import { LogColorWrapper, PackageUtil, parseArgsMap } from '@proteinjs/util-node';
+import { Logger } from '@proteinjs/util';
+import { primaryLogColor, secondaryLogColor } from './logColors';
 
 /**
  * Symlink dependencies to local packages for each package in the workspace.
- * 
+ *
  * ie: `npx symlink-workspace --skip=@some/package,@another/package`
- * 
+ *
  * Optional args:
- * 
+ *
  * --skip=@some/package,@another/package
  */
 export const symlinkWorkspace = async () => {
@@ -18,32 +18,39 @@ export const symlinkWorkspace = async () => {
   const workspacePath = process.cwd();
   const { packageMap, sortedPackageNames } = await PackageUtil.getWorkspaceMetadata(workspacePath);
   const skippedPackages = ['root'];
-  const filteredPackageNames = sortedPackageNames.filter(packageName => !(args.skip && args.skip.includes(packageName)) && !skippedPackages.includes(packageName));
+  const filteredPackageNames = sortedPackageNames.filter(
+    (packageName) => !(args.skip && args.skip.includes(packageName)) && !skippedPackages.includes(packageName)
+  );
   if (filteredPackageNames.length == 0) {
     logger.info(`> There are no packages to symlink in workspace (${workspacePath})`);
     return;
   }
 
-  logger.info(`> Symlinking ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
-  for (let packageName of filteredPackageNames) {
+  logger.info(
+    `> Symlinking ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`
+  );
+  for (const packageName of filteredPackageNames) {
     const localPackage = packageMap[packageName];
     await PackageUtil.symlinkDependencies(localPackage, packageMap, logger);
   }
-  logger.info(`> Symlinked ${cw.color(`${filteredPackageNames.length}`, secondaryLogColor)} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
-}
+  logger.info(
+    `> Symlinked ${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(2));
-  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;
-}
+}

package/src/testWorkspace.ts

@@ -1,22 +1,31 @@
-import * as path from 'path'
-import { PackageUtil, cmd, WorkspaceMetadata } from '@proteinjs/util-node'
-import { Logger } from '@proteinjs/util'
+import * as path from 'path';
+import { PackageUtil, cmd, WorkspaceMetadata } from '@proteinjs/util-node';
+import { Logger } from '@proteinjs/util';
 
 export const testWorkspace = async (workspaceMetadata?: WorkspaceMetadata) => {
   const logger = new Logger('workspace:test');
   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?.test && !skippedPackages.includes(packageName));
+  const filteredPackageNames = sortedPackageNames.filter(
+    (packageName) => !!packageMap[packageName].packageJson.scripts?.test && !skippedPackages.includes(packageName)
+  );
 
-  logger.info(`> Testing ${filteredPackageNames.length} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
-  for (let packageName of filteredPackageNames) {
+  logger.info(
+    `> Testing ${filteredPackageNames.length} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`
+  );
+  for (const packageName of filteredPackageNames) {
     const localPackage = packageMap[packageName];
     const packageDir = path.dirname(localPackage.filePath);
-    if (!await PackageUtil.hasTests(packageDir))
+    if (!(await PackageUtil.hasTests(packageDir))) {
       continue;
+    }
 
     await cmd('npm', ['run', 'test'], { cwd: packageDir });
   }
-  logger.info(`> Finished testing ${filteredPackageNames.length} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`);
-}
+  logger.info(
+    `> Finished testing ${filteredPackageNames.length} package${filteredPackageNames.length != 1 ? 's' : ''} in workspace (${workspacePath})`
+  );
+};

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 && localPackage.workspace.lernaJson && localPackage.workspace.lernaJson.version !== 'independent') {
+    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(workspacePath, workspacePackages);
-    if (!syncedVersion)
+    if (!syncedVersion) {
       continue;
+    }
 
     await pushAndTagFixedVersionRepo(workspacePath, syncedVersion);
   }
@@ -155,37 +201,43 @@ async function syncFixedVersionWorkspaces(fixedVersionWorkspacePaths: string[],
   logger.info(`> Synced fixed-version workspaces`);
 }
 
-async function syncFixedVersions(workspacePath: string, 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)
+    if (!lernaJson) {
       throw new Error(`Cannot find lerna.json for workspace: ${workspacePath}`);
+    }
 
     const lernaJsonPath = path.join(workspacePath, 'lerna.json');
     lernaJson.version = highestVersion;
@@ -224,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);
@@ -232,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;
 }
@@ -242,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);
@@ -250,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;
@@ -258,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})`);
@@ -277,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);
   }
@@ -295,7 +377,7 @@ async function getLatestCommitSha(dir: string): Promise<string> {
       resolve(stdout.trim());
     });
   });
-};
+}
 
 type RepoInfo = {
   owner: string;
@@ -313,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;
@@ -325,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) {
@@ -340,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`);
-}
+}