@xylabs/ts-scripts-yarn3 2.15.0 → 2.16.0-rc.1

package/src/actions/package/clean-outputs.ts

@@ -0,0 +1,15 @@
+import chalk from 'chalk'
+import { rmSync } from 'fs'
+
+export const packageCleanOutputs = () => {
+  const pkg = process.env.INIT_CWD
+  const pkgName = process.env.npm_package_name
+  console.log(chalk.green(`Cleaning Outputs [${pkgName}]`))
+
+  const dist = `${pkg}/dist`
+  rmSync(dist, { force: true, recursive: true })
+
+  const build = `${pkg}/build`
+  rmSync(build, { force: true, recursive: true })
+  return 0
+}

package/src/actions/package/clean-typescript.ts

@@ -0,0 +1,13 @@
+import chalk from 'chalk'
+import { rimrafSync } from 'rimraf'
+
+export const packageCleanTypescript = () => {
+  const pkg = process.env.INIT_CWD
+  const pkgName = process.env.npm_package_name
+  console.log(chalk.green(`Cleaning Typescript [${pkgName}]`))
+
+  rimrafSync(`${pkg}/*.tsbuildinfo`)
+  rimrafSync(`${pkg}/.tsconfig.*`)
+
+  return 0
+}

package/src/actions/package/clean.ts

@@ -1,18 +1,6 @@
-import chalk from 'chalk'
-import { rmSync } from 'fs'
-import { rimrafSync } from 'rimraf'
+import { packageCleanOutputs } from './clean-outputs'
+import { packageCleanTypescript } from './clean-typescript'
 
 export const packageClean = () => {
-  const pkg = process.env.INIT_CWD
-  const pkgName = process.env.npm_package_name
-  console.log(chalk.green(`Cleaning [${pkgName}]`))
-
-  const dist = `${pkg}/dist`
-  rmSync(dist, { force: true, recursive: true })
-
-  const build = `${pkg}/build`
-  rmSync(build, { force: true, recursive: true })
-
-  rimrafSync(`${pkg}/**/*.tsbuildinfo`)
-  rimrafSync(`${pkg}/**/.tsconfig.*`)
+  return packageCleanOutputs() + packageCleanTypescript()
 }

package/src/actions/package/deps.ts

@@ -3,6 +3,8 @@ import chalk from 'chalk'
 import depcheck, { special } from 'depcheck'
 import { existsSync, readFileSync } from 'fs'
 
+import { checkResult } from '../../lib'
+
 export const packageDeps = async () => {
   const pkg = process.env.INIT_CWD
   const pkgName = process.env.npm_package_name
@@ -93,6 +95,9 @@ export const packageDeps = async () => {
     })
     console.log(chalk.yellow(message.join('\n')))
   }
+
+  checkResult(`Deps [${pkgName}]`, errorCount, 'warn', false)
+
   //returning 0 here since we never want deps to be fatal
   return 0
 }

package/src/actions/package/index.ts

@@ -1,9 +1,12 @@
 export * from './clean'
+export * from './clean-outputs'
+export * from './clean-typescript'
 export * from './compile'
 export * from './compile-cjs'
 export * from './compile-esm'
 export * from './copy-assets'
 export * from './deps'
 export * from './gen-docs'
+export * from './recompile'
 export * from './tsconfig-gen-cjs'
 export * from './tsconfig-gen-esm'

package/src/actions/package/recompile.ts

@@ -0,0 +1,7 @@
+import { packageClean } from './clean'
+import { packageCompileCjs } from './compile-cjs'
+import { packageCompileEsm } from './compile-esm'
+
+export const packageRecompile = async () => {
+  return (await Promise.all([packageClean(), packageCompileEsm(), packageCompileCjs()])).reduce((prev, value) => prev + value, 0)
+}

package/src/actions/package/tsconfig-gen-esm.ts

@@ -3,7 +3,7 @@ import { readFileSync, writeFileSync } from 'fs'
 
 import { createBuildConfig } from '../../lib'
 
-export const packageTsconfigGenEsm = () => {
+export const packageTsconfigGenEsm = (quiet = false) => {
   const pkg = process.env.INIT_CWD ?? './'
   const pkgName = process.env.npm_package_name
 
@@ -19,7 +19,9 @@ export const packageTsconfigGenEsm = () => {
         currentConfig = undefined
       }
       if (currentConfig !== config) {
-        console.log(chalk.gray(`Updating ESM tsconfig [${pkgName}]`))
+        if (!quiet) {
+          console.log(chalk.gray(`Updating ESM tsconfig [${pkgName}]`))
+        }
         writeFileSync(`${pkg}/.tsconfig.build.esm.json`, config, { encoding: 'utf8' })
       }
     }

package/src/actions/recompile.ts

@@ -0,0 +1,45 @@
+import chalk from 'chalk'
+
+import { runStepsAsync } from '../lib'
+
+export interface RecompileParams {
+  incremental?: boolean
+  jobs?: number
+  pkg?: string
+  target?: 'esm' | 'cjs'
+  verbose?: boolean
+}
+
+export interface RecompilePackageParams {
+  pkg: string
+  target?: 'esm' | 'cjs'
+  verbose?: boolean
+}
+
+export const recompile = async ({ verbose, target, pkg, incremental }: RecompileParams) => {
+  return pkg ? await recompilePackage({ pkg, target, verbose }) : await recompileAll({ incremental, target, verbose })
+}
+
+export const recompilePackage = ({ verbose, target, pkg }: RecompilePackageParams) => {
+  const verboseOptions = verbose ? ['-v'] : []
+  const targetOptions = target ? ['-t', target] : []
+
+  return runStepsAsync(`Recompile [${pkg}]`, [['yarn', ['workspace', pkg, 'run', 'package-recompile', ...verboseOptions, ...targetOptions]]])
+}
+
+export const recompileAll = async ({ jobs, verbose, target, incremental }: RecompileParams) => {
+  const start = Date.now()
+  const verboseOptions = verbose ? ['-v'] : []
+  const targetOptions = target ? ['-t', target] : []
+  const incrementalOptions = incremental ? ['--since', '-ptA'] : ['-ptA']
+  const jobsOptions = jobs ? ['-j', `${jobs}`] : []
+  if (jobs) {
+    console.log(chalk.blue(`Jobs set to [${jobs}]`))
+  }
+
+  const result = await runStepsAsync(`Recompile${incremental ? '-Incremental' : ''} [All]`, [
+    ['yarn', ['workspaces', 'foreach', ...incrementalOptions, ...jobsOptions, 'run', 'package-recompile', ...verboseOptions, ...targetOptions]],
+  ])
+  console.log(`${chalk.gray('Recompiled in')} [${chalk.magenta(((Date.now() - start) / 1000).toFixed(2))}] ${chalk.gray('seconds')}`)
+  return result
+}

package/src/bin/package/clean-outputs.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { packageCleanOutputs } from '../../actions'
+
+packageCleanOutputs()

package/src/bin/package/clean-typescript.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { packageCleanTypescript } from '../../actions'
+
+packageCleanTypescript()

package/src/bin/package/recompile.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk'
+import { packageRecompile } from '../../actions'
+
+packageRecompile().then((value) => process.exitCode = value).catch((reason) => {
+  console.error(chalk.red(reason))
+  process.exitCode = 1
+})

package/src/bin/recompile.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runXyWithWarning } from "../lib"
+
+runXyWithWarning('recompile')

package/src/lib/checkResult.ts

@@ -0,0 +1,12 @@
+import chalk from 'chalk'
+
+export const checkResult = (name: string, result: number, level: 'error' | 'warn' = 'error', exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? '[Exiting Process]' : '[Continuing]'
+    const chalkFunc = level === 'error' ? chalk.red : chalk.yellow
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`))
+    if (exitOnFail) {
+      process.exit(result)
+    }
+  }
+}

package/src/lib/dependencies/detectDuplicateDependencies.ts

@@ -19,24 +19,25 @@ export const detectDuplicateDependencies = (depsFromPackageJSON?: string[], Defa
         } catch (e) {
           console.error(`Error running yarn why: ${e}`)
           exitCode = 1
-          return
+          return exitCode
         }
 
         if (output) {
           exitCode = new DuplicateDetector(output, dependency).detect()
-          return
+          return exitCode
         } else {
           console.log(`${dependency} - N/A`)
           if (depsFromPackageJSON) {
             console.log(`🚨 Library ${dependency} was requested in package.json but not found`)
           }
           exitCode = 1
-          return
+          return exitCode
         }
       })
       return exitCode
     } else {
       console.log('🚨 No dependencies where passed')
+      return exitCode
     }
   })
 }

package/src/lib/index.ts

@@ -1,3 +1,4 @@
+export * from './checkResult'
 export * from './createBuildConfig'
 export * from './defaultBuildConfig'
 export * from './dependencies'

package/src/lib/runSteps.ts

@@ -2,16 +2,18 @@ import chalk from 'chalk'
 import { spawnSync, SpawnSyncOptionsWithBufferEncoding } from 'child_process'
 import { existsSync } from 'fs'
 
+import { checkResult } from './checkResult'
 import { safeExit } from './safeExit'
 
 export type ScriptStep =
-  | [/*command*/ 'yarn' | 'node' | 'ts-node-script' | 'tsc', /*arg*/ string | string[]]
+  | [/*command*/ 'yarn' | 'node' | 'ts-node-script' | 'tsc' | 'jest', /*arg*/ string | string[]]
   | [/*command*/ string, /*arg*/ string | string[], /*config*/ SpawnSyncOptionsWithBufferEncoding]
 
-export const runSteps = (name: string, steps: ScriptStep[], exitOnFail = true, messages?: string[]) => {
+export const runSteps = (name: string, steps: ScriptStep[], exitOnFail = true, messages?: string[]): number => {
   return safeExit(() => {
     const pkgName = process.env.npm_package_name
     console.log(chalk.green(`${name} [${pkgName}]`))
+    let totalStatus = 0
     for (let i = 0; i < steps.length; i++) {
       const [command, args, config] = steps[i]
       if (messages?.[i]) {
@@ -21,17 +23,17 @@ export const runSteps = (name: string, steps: ScriptStep[], exitOnFail = true, m
       if (command === 'node' && !existsSync(argList[0])) {
         throw Error(`File not found [${argList[0]}]`)
       }
-      const status = spawnSync(command, Array.isArray(args) ? args : args.split(' '), {
-        ...config,
-        encoding: 'utf8',
-        env: { FORCE_COLOR: '3', ...process.env },
-        shell: true,
-        stdio: 'inherit',
-      }).status
-      if (status && exitOnFail) {
-        return status
-      }
+      const status =
+        spawnSync(command, Array.isArray(args) ? args : args.split(' '), {
+          ...config,
+          encoding: 'utf8',
+          env: { FORCE_COLOR: '3', ...process.env },
+          shell: true,
+          stdio: 'inherit',
+        }).status ?? 0
+      checkResult(name, status, 'error', exitOnFail)
+      totalStatus += status ?? 0
     }
-    return 0
-  })
+    return totalStatus
+  }, !!exitOnFail)
 }

package/src/lib/runStepsAsync.ts

@@ -2,9 +2,11 @@ import chalk from 'chalk'
 import { spawn } from 'child_process'
 import { existsSync } from 'fs'
 
+import { checkResult } from './checkResult'
 import { ScriptStep } from './runSteps'
+import { safeExitAsync } from './safeExit'
 
-export const runStepAsync = (step: ScriptStep, exitOnFail = true, message?: string) => {
+export const runStepAsync = (name: string, step: ScriptStep, exitOnFail = true, message?: string) => {
   return new Promise<number>((resolve) => {
     const [command, args, config] = step
     if (message) {
@@ -28,9 +30,7 @@ export const runStepAsync = (step: ScriptStep, exitOnFail = true, message?: stri
             )}`,
           ),
         )
-        if (exitOnFail) {
-          process.exit(code)
-        }
+        checkResult(name, code, 'error', exitOnFail)
         resolve(code)
       } else {
         resolve(0)
@@ -40,16 +40,13 @@ export const runStepAsync = (step: ScriptStep, exitOnFail = true, message?: stri
 }
 
 export const runStepsAsync = async (name: string, steps: ScriptStep[], exitOnFail = true, messages?: string[]) => {
-  try {
+  return await safeExitAsync(async () => {
     const pkgName = process.env.npm_package_name
     console.log(chalk.green(`${name} [${pkgName}]`))
     let result = 0
     for (let i = 0; i < steps.length; i++) {
-      result += await runStepAsync(steps[i], exitOnFail, messages?.[i])
+      result += await runStepAsync(name, steps[i], exitOnFail, messages?.[i])
     }
     return result
-  } catch (ex) {
-    console.error(chalk.red(ex))
-    process.exit(-1)
-  }
+  })
 }

package/src/lib/safeExit.ts

@@ -2,16 +2,28 @@
 
 import { processEx } from './processEx'
 
-const safeExit = (func: () => number | undefined) => {
+const safeExit = (func: () => number, exitOnFail = true): number => {
   try {
     const result = func()
-    if (result) {
+    if (result && exitOnFail) {
       process.exit(result)
     }
     return result
   } catch (ex) {
-    processEx(ex)
+    return processEx(ex)
   }
 }
 
-export { safeExit }
+const safeExitAsync = async (func: () => Promise<number>, exitOnFail = true): Promise<number> => {
+  try {
+    const result = await func()
+    if (result && exitOnFail) {
+      process.exit(result)
+    }
+    return result
+  } catch (ex) {
+    return processEx(ex)
+  }
+}
+
+export { safeExit, safeExitAsync }

package/src/lib/xy/xyBuildCommands.ts

@@ -1,6 +1,6 @@
 import yargs from 'yargs'
 
-import { build, compile, copyAssets, rebuild } from '../../actions'
+import { build, compile, copyAssets, rebuild, recompile } from '../../actions'
 
 export const xyBuildCommands = (args: yargs.Argv) => {
   return args
@@ -47,6 +47,27 @@ export const xyBuildCommands = (args: yargs.Argv) => {
         })
       },
     )
+    .command(
+      'recompile [package]',
+      'Re-compile with Typescript & Copy Images',
+      (yargs) => {
+        return yargs.positional('package', {
+          describe: 'Specific package to re-compile',
+        })
+      },
+      async (argv) => {
+        if (argv.verbose) {
+          console.log(`Re-compiling: ${argv.package ?? 'all'}`)
+        }
+        process.exitCode = await recompile({
+          incremental: !!argv.incremental,
+          jobs: argv.jobs as number,
+          pkg: argv.package as string,
+          target: argv.target as 'esm' | 'cjs',
+          verbose: !!argv.verbose,
+        })
+      },
+    )
     .command(
       'rebuild [package]',
       'Rebuild - Clean, Compile & Lint',