@xylabs/ts-scripts-yarn3 6.0.9 → 6.1.1

package/src/actions/package/deps.ts

@@ -1,144 +0,0 @@
-/* eslint-disable max-statements */
-import { existsSync, readFileSync } from 'node:fs'
-import { cwd } from 'node:process'
-
-import chalk from 'chalk'
-import depcheck from 'depcheck'
-const special = depcheck.special
-
-import { checkResult } from '../../lib/index.ts'
-
-const defaultIgnorePatterns = ['*.d.ts', 'dist', '.*', 'node_modules']
-const defaultIgnoreDevDeps = [
-  '@xylabs/ts-scripts-yarn3',
-  '@xylabs/tsconfig',
-  '@xylabs/tsconfig-dom',
-  '@xylabs/tsconfig-react',
-  'typescript',
-]
-const defaultIgnoreDevPatterns = ['*.stories.*', '*.spec.*', 'spec', 'stories', 'tsconfig.json']
-
-const reportUnused = (name: string, unused: depcheck.Results['dependencies']) => {
-  if (unused.length > 0) {
-    const message = [chalk.yellow(`${unused.length} Unused ${name}`)]
-    for (const value of unused) message.push(chalk.gray(`  ${value}`))
-    console.log(message.join('\n'))
-  }
-}
-
-const reportMissing = (name: string, missing: depcheck.Results['missing']) => {
-  if (Object.keys(missing).length > 0) {
-    const message = [chalk.yellow(`${Object.entries(missing).length} Missing ${name}`)]
-    for (const [key, value] of Object.entries(missing)) {
-      message.push(`${key}`, chalk.gray(`  ${value.at(0)}`))
-    }
-    console.log(chalk.yellow(message.join('\n')))
-  }
-}
-
-const analyzeDeps = async (pkg: string, ignoreMatches: string[]) => {
-  const packageContent = existsSync(`${pkg}/package.json`) ? JSON.parse(readFileSync(`${pkg}/package.json`, { encoding: 'utf8' })) : undefined
-  const [srcUnused, allUnused] = await Promise.all([
-    depcheck(`${pkg}/src`, {
-      ignoreMatches,
-      ignorePatterns: [...defaultIgnoreDevPatterns, ...defaultIgnorePatterns],
-      package: packageContent,
-    }),
-    depcheck(`${pkg}/.`, {
-      ignoreMatches: [...ignoreMatches, ...defaultIgnoreDevDeps],
-      ignorePatterns: [...defaultIgnorePatterns],
-      package: packageContent,
-      specials: [special.eslint, special.babel, special.bin, special.prettier, special.jest, special.mocha],
-    }),
-  ])
-
-  const unusedDeps = srcUnused.dependencies
-  const unusedDevDeps = allUnused.devDependencies
-  const usedDeps = srcUnused.using
-  const usedDevDeps = allUnused.using
-  const missing = { ...srcUnused.missing, ...allUnused.missing }
-  const { invalidDirs, invalidFiles } = allUnused
-
-  return {
-    invalidDirs, invalidFiles, missing, unusedDeps, unusedDevDeps, usedDeps, usedDevDeps,
-  }
-}
-
-export const packageDeps = async () => {
-  const pkg = process.env.INIT_CWD ?? cwd()
-  const pkgName = process.env.npm_package_name
-
-  const packageContent = existsSync(`${pkg}/package.json`) ? JSON.parse(readFileSync(`${pkg}/package.json`, { encoding: 'utf8' })) : undefined
-
-  const rawIgnore
-    = existsSync(`${pkg}/.depcheckrc`) ? readFileSync(`${pkg}/.depcheckrc`, { encoding: 'utf8' }).replace('ignores:', '"ignores":') : undefined
-  let ignoreMatches: string[] = []
-  try {
-    ignoreMatches = rawIgnore ? (JSON.parse(`{${rawIgnore}}`).ignores as string[]) : []
-  } catch (ex) {
-    const error = ex as Error
-    console.log(`${pkgName} [${error.message}] Failed to parse .depcheckrc [${rawIgnore}]`)
-  }
-
-  const {
-    invalidDirs, invalidFiles, unusedDeps, unusedDevDeps, usedDeps, usedDevDeps, missing,
-  } = await analyzeDeps(pkg, ignoreMatches)
-
-  const declaredDeps = Object.keys(packageContent.dependencies ?? {})
-  const declaredPeerDeps = Object.keys(packageContent.peerDependencies ?? {})
-  const declaredDevDeps = Object.keys(packageContent.devDependencies ?? {})
-
-  const missingDeps = Object.keys(usedDeps).filter(
-    key => !declaredDeps.includes(key) && !declaredPeerDeps.includes(key) && !key.startsWith('@types/'),
-  )
-
-  const missingDevDeps = Object.keys(usedDevDeps).filter(key => !declaredDevDeps.includes(key) && !declaredDeps.includes(key))
-
-  const missingDepsObject: Record<string, string[]> = {}
-  for (const key of missingDeps) {
-    missingDepsObject[key] = missing[key] ?? [`devDep should be dep [${key}]`]
-  }
-
-  const missingDevDepsObject: Record<string, string[]> = {}
-  for (const key of missingDevDeps) {
-    if (missing[key]) {
-      missingDevDepsObject[key] = missing[key]
-    }
-  }
-
-  const errorCounts = [
-    unusedDeps.length,
-    unusedDevDeps.length,
-    Object.entries(invalidDirs).length,
-    Object.entries(invalidFiles).length,
-    Object.entries(missingDepsObject).length,
-    Object.entries(missingDevDepsObject).length,
-  ]
-
-  const errorCount = errorCounts.reduce((prev, count) => prev + count, 0)
-
-  if (errorCount > 0) {
-    console.log(`Deps [${pkgName}] = (${JSON.stringify(errorCounts)})`)
-  } else {
-    console.log(`Deps [${pkgName}] - Ok`)
-  }
-
-  reportUnused('dependencies', unusedDeps)
-  reportUnused('devDependencies', unusedDevDeps)
-
-  if (Object.entries(invalidDirs).length > 0) {
-    for (const [key, value] of Object.entries(invalidDirs)) console.warn(chalk.gray(`Invalid Dir: ${key}: ${value}`))
-  }
-
-  if (Object.entries(invalidFiles).length > 0) {
-    for (const [key, value] of Object.entries(invalidFiles)) console.warn(chalk.gray(`Invalid File: ${key}: ${value}`))
-  }
-
-  reportMissing('dependencies', missingDepsObject)
-  reportMissing('devDependencies', missingDevDepsObject)
-
-  checkResult(`Deps [${pkgName}]`, errorCount, 'warn', false)
-
-  // returning 0 here since we never want deps to be fatal
-  return 0
-}

package/src/actions/package/gen-docs.ts

@@ -1,126 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-
-import chalk from 'chalk'
-import {
-  Application, ArgumentsReader, TSConfigReader, TypeDocReader,
-} from 'typedoc'
-
-const ExitCodes = {
-  CompileError: 3,
-  ExceptionThrown: 6,
-  NoEntryPoints: 2,
-  Ok: 0,
-  OptionError: 1,
-  OutputError: 5,
-  ValidationError: 4,
-}
-
-export const packageGenDocs = async () => {
-  const pkg = process.env.INIT_CWD
-
-  if (pkg && !existsSync(path.join(pkg, 'typedoc.json'))) {
-    return
-  }
-
-  const app = await Application.bootstrap({
-    entryPointStrategy: 'merge',
-    entryPoints: [`${pkg}/src/**/*.ts`, `${pkg}/packages/*/dist/docs.json`],
-    excludeExternals: true,
-    json: `${pkg}/dist/docs.json`,
-    logLevel: 'Error',
-    tsconfig: `${pkg}/tsconfig.json`,
-  })
-
-  app.options.addReader(new ArgumentsReader(0))
-  app.options.addReader(new TypeDocReader())
-  app.options.addReader(new TSConfigReader())
-  app.options.addReader(new ArgumentsReader(300))
-
-  return await runTypeDoc(app)
-}
-
-const runTypeDoc = async (app: Application) => {
-  const pkgName = process.env.npm_package_name
-  if (app.options.getValue('version')) {
-    console.log(app.toString())
-    return ExitCodes.Ok
-  }
-
-  if (app.options.getValue('showConfig')) {
-    console.log(app.options.getRawValues())
-    return ExitCodes.Ok
-  }
-
-  if (app.logger.hasErrors()) {
-    return ExitCodes.OptionError
-  }
-  if (app.options.getValue('treatWarningsAsErrors') && app.logger.hasWarnings()) {
-    return ExitCodes.OptionError
-  }
-
-  if (app.options.getValue('entryPoints').length === 0) {
-    app.logger.error('No entry points provided')
-    return ExitCodes.NoEntryPoints
-  }
-
-  if (app.options.getValue('watch')) {
-    await app.convertAndWatch(async (project) => {
-      const out = app.options.getValue('out')
-      if (out) {
-        await app.generateDocs(project, out)
-      }
-      const json = app.options.getValue('json')
-      if (json) {
-        await app.generateJson(project, json)
-      }
-
-      if (!out && !json) {
-        await app.generateDocs(project, './docs')
-      }
-    })
-    return ExitCodes.Ok
-  }
-
-  const project = await app.convert()
-  if (!project) {
-    return ExitCodes.CompileError
-  }
-  if (app.options.getValue('treatWarningsAsErrors') && app.logger.hasWarnings()) {
-    return ExitCodes.CompileError
-  }
-
-  app.validate(project)
-  if (app.logger.hasErrors()) {
-    return ExitCodes.ValidationError
-  }
-  if (app.options.getValue('treatWarningsAsErrors') && app.logger.hasWarnings()) {
-    return ExitCodes.ValidationError
-  }
-
-  if (app.options.getValue('emit') !== 'none') {
-    const out = app.options.getValue('out')
-    if (out) {
-      await app.generateDocs(project, out)
-    }
-    const json = app.options.getValue('json')
-    if (json) {
-      await app.generateJson(project, json)
-    }
-
-    if (!out && !json) {
-      await app.generateDocs(project, './docs')
-    }
-
-    if (app.logger.hasErrors()) {
-      return ExitCodes.OutputError
-    }
-    if (app.options.getValue('treatWarningsAsErrors') && app.logger.hasWarnings()) {
-      return ExitCodes.OutputError
-    }
-  }
-  console.log(chalk.green(`${pkgName} - Ok`))
-  return ExitCodes.Ok
-}

package/src/actions/package/index.ts

@@ -1,10 +0,0 @@
-export * from './clean.ts'
-export * from './clean-outputs.ts'
-export * from './clean-typescript.ts'
-export * from './compile/index.ts'
-export * from './copy-assets.ts'
-export * from './deps.ts'
-export * from './gen-docs.ts'
-export * from './lint.ts'
-export * from './publint.ts'
-export * from './recompile.ts'

package/src/actions/package/lint.ts

@@ -1,86 +0,0 @@
-import { readdirSync } from 'node:fs'
-import path from 'node:path'
-import { cwd } from 'node:process'
-import { pathToFileURL } from 'node:url'
-
-import chalk from 'chalk'
-import { ESLint } from 'eslint'
-import { findUp } from 'find-up'
-import picomatch from 'picomatch'
-
-const dumpMessages = (lintResults: ESLint.LintResult[]) => {
-  const colors: ('white' | 'red' | 'yellow')[] = ['white', 'yellow', 'red']
-  const severity: string[] = ['none', 'warning', 'error']
-
-  for (const lintResult of lintResults) {
-    if (lintResult.messages.length > 0) {
-      console.log(chalk.gray(`\n${lintResult.filePath}`))
-      for (const message of lintResult.messages) {
-        console.log(
-          chalk.gray(`\t${message.line}:${message.column}`),
-          chalk[colors[message.severity]](`\t${severity[message.severity]}`),
-          chalk.white(`\t${message.message}`),
-          chalk.gray(`\t${message.ruleId}`),
-        )
-      }
-    }
-  }
-}
-
-async function getRootESLintConfig() {
-  // Locate the root eslint.config.mjs
-  const configPath = await findUp('eslint.config.mjs')
-
-  if (!configPath) {
-    throw new Error('eslint.config.mjs not found in the monorepo')
-  }
-
-  return pathToFileURL(configPath)
-}
-
-function getFiles(dir: string, ignoreFolders: string[]): string[] {
-  const currentDirectory = cwd()
-  const subDirectory = dir.split(currentDirectory)[1]
-  if (ignoreFolders.includes(subDirectory)) return []
-  return readdirSync(dir, { withFileTypes: true })
-    .flatMap((dirent) => {
-      const res = path.resolve(dir, dirent.name)
-      const relativePath = subDirectory ? `${subDirectory}/${dirent.name}` : dirent.name
-
-      const ignoreMatchers = ignoreFolders.map(pattern => picomatch(pattern))
-
-      // Exclude ignored paths
-      if (ignoreMatchers.some(isMatch => isMatch(relativePath))) return []
-
-      return dirent.isDirectory()
-        ? getFiles(res, ignoreFolders)
-        : [res]
-    })
-}
-
-export const packageLint = async (fix = false, verbose = false, cache = true) => {
-  const pkg = process.env.INIT_CWD
-  const configPath = await getRootESLintConfig()
-  const { default: eslintConfig } = await import(configPath.href)
-
-  // List of folders to ignore
-  const ignoreFolders = ['node_modules', 'dist', 'packages', '.git', 'build', '.yarn', '.vscode', '.github']
-
-  const engine = new ESLint({
-    baseConfig: [...eslintConfig], fix, warnIgnored: false, cache,
-  })
-
-  const files = getFiles(cwd(), ignoreFolders)
-  if (verbose) {
-    console.log(chalk.green(`Linting ${pkg} [files = ${files.length}]`))
-  }
-  const lintResults = await engine.lintFiles(files)
-
-  dumpMessages(lintResults)
-
-  if (fix) {
-    await ESLint.outputFixes(lintResults)
-  }
-
-  return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0)
-}

package/src/actions/package/publint.ts

@@ -1,75 +0,0 @@
-import { promises as fs } from 'node:fs'
-
-import chalk from 'chalk'
-import type { Message } from 'publint'
-import sortPackageJson from 'sort-package-json'
-
-export interface PackagePublintParams { verbose?: boolean }
-
-export const packagePublint = async (params?: PackagePublintParams) => {
-  const pkgDir = process.env.INIT_CWD
-
-  const sortedPkg = sortPackageJson(await fs.readFile(`${pkgDir}/package.json`, 'utf8'))
-  await fs.writeFile(`${pkgDir}/package.json`, sortedPkg)
-
-  const pkg = JSON.parse(await fs.readFile(`${pkgDir}/package.json`, 'utf8'))
-
-  console.log(chalk.green(`Publint: ${pkg.name}`))
-  console.log(chalk.gray(pkgDir))
-
-  const { publint } = await import('publint')
-
-  const { messages } = await publint({
-    level: 'suggestion',
-    pkgDir,
-    strict: true,
-  })
-
-  // eslint-disable-next-line import-x/no-internal-modules
-  const { formatMessage } = await import('publint/utils')
-
-  const validMessage = (_message: Message): boolean => {
-    return true
-    /* try {
-      const value = getValueFromPath(pkg, message.path)
-      switch (message.code) {
-        case 'FILE_INVALID_FORMAT':
-          return !message.args?.actualFilePath?.includes('dist/browser') && !value?.includes('dist/browser')
-        case 'EXPORT_TYPES_INVALID_FORMAT':
-          return !`${value}`.includes('dist/browser')
-        default:
-          return true
-      }
-    } catch (ex) {
-      const error = ex as Error
-      console.error(chalk.red(`validMessage Excepted: ${error.message}`))
-      console.error(chalk.gray(JSON.stringify(error.stack)))
-      return true
-    } */
-  }
-
-  // we filter out invalid file formats for the esm folder since it is intentionally done
-  const validMessages = messages.filter(validMessage)
-  for (const message of validMessages) {
-    switch (message.type) {
-      case 'error': {
-        console.error(chalk.red(`[${message.code}] ${formatMessage(message, pkg)}`))
-        break
-      }
-      case 'warning': {
-        console.warn(chalk.yellow(`[${message.code}] ${formatMessage(message, pkg)}`))
-        break
-      }
-      default: {
-        console.log(chalk.white(`[${message.code}] ${formatMessage(message, pkg)}`))
-        break
-      }
-    }
-  }
-
-  if (params?.verbose) {
-    console.log(chalk.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`))
-  }
-
-  return validMessages.filter(message => message.type === 'error').length
-}

package/src/actions/package/recompile.ts

@@ -1,6 +0,0 @@
-import { packageClean } from './clean.ts'
-import { packageCompile } from './compile/index.ts'
-
-export const packageRecompile = async () => {
-  return await packageClean() || await packageCompile()
-}

package/src/actions/publint.ts

@@ -1,26 +0,0 @@
-import { runSteps, runStepsAsync } from '../lib/index.ts'
-
-export interface PublintParams {
-  pkg?: string
-  verbose?: boolean
-}
-
-export interface PublintPackageParams {
-  pkg: string
-  verbose?: boolean
-}
-
-export const publint = async ({ verbose, pkg }: PublintParams) => {
-  return pkg
-    ? await publintPackage({ pkg, verbose })
-    : publintAll({ verbose })
-}
-
-export const publintPackage = ({ pkg }: PublintPackageParams) => {
-  return runStepsAsync(`Publint [${pkg}]`, [['yarn', ['workspace', pkg, 'run', 'package-publint']]])
-}
-
-export const publintAll = ({ verbose }: PublintParams) => {
-  const verboseOptions = verbose ? ['--verbose'] : ['--no-verbose']
-  return runSteps('Publint', [['yarn', ['workspaces', 'foreach', '-pA', ...verboseOptions, 'run', 'package-publint']]])
-}

package/src/actions/rebuild.ts

@@ -1,13 +0,0 @@
-import { runSteps } from '../lib/index.ts'
-
-export interface RebuildParams {
-  pkg?: string
-  target?: 'esm' | 'cjs'
-}
-
-export const rebuild = ({ target }: RebuildParams) => {
-  return runSteps('Rebuild', [
-    ['yarn', 'xy clean'],
-    ['yarn', target ? `xy build -t ${target}` : 'xy build'],
-  ])
-}

package/src/actions/recompile.ts

@@ -1,81 +0,0 @@
-import chalk from 'chalk'
-
-import { runStepsAsync } from '../lib/index.ts'
-
-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 = ({ target, pkg }: RecompilePackageParams) => {
-  const targetOptions = target ? ['-t', target] : []
-
-  return runStepsAsync(
-    `Recompile [${pkg}]`,
-    [['yarn', ['workspace', pkg, 'run', 'package-recompile', ...targetOptions]]],
-  )
-}
-
-export const recompileAll = async ({
-  jobs, verbose, target, incremental,
-}: RecompileParams) => {
-  const start = Date.now()
-  const verboseOptions = verbose ? ['--verbose'] : ['--no-verbose']
-  const targetOptions = target ? ['-t', target] : []
-  const incrementalOptions = incremental
-    ? ['--since', '-Apt', '--topological-dev']
-    : ['--parallel', '-Apt', '--topological-dev']
-  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,
-        ...verboseOptions,
-        'run',
-        'package-clean',
-        ...targetOptions],
-    ],
-    ['yarn',
-      [
-        'workspaces',
-        'foreach',
-        ...incrementalOptions,
-        ...jobsOptions,
-        ...verboseOptions,
-        'run',
-        'package-compile',
-        ...targetOptions]],
-  ])
-  console.log(
-    `${chalk.gray('Recompiled in')} [${chalk.magenta(((Date.now() - start) / 1000).toFixed(2))}] ${chalk.gray('seconds')}`,
-  )
-  return result
-}

package/src/actions/reinstall.ts

@@ -1,29 +0,0 @@
-import {
-  closeSync, openSync, rmSync,
-} from 'node:fs'
-
-import { runSteps, yarnWorkspaces } from '../lib/index.ts'
-
-export const reinstall = () => {
-  console.log('Reinstall [Clear Lock File]')
-  closeSync(openSync('./yarn.lock', 'w'))
-
-  console.log('Reinstall [Clear Node Modules]')
-  const workspaces = yarnWorkspaces()
-  const result = workspaces
-    .map(({ location, name }) => {
-      const dist = `${location}/node_modules`
-      try {
-        rmSync(dist, { force: true, recursive: true })
-        return 0
-      } catch (ex) {
-        const error = ex as Error
-        console.error(`Reinstall [Clear Node Modules] Failed [${name}, ${error.message}]`)
-        return 1
-      }
-    })
-    // eslint-disable-next-line unicorn/no-array-reduce
-    .reduce((prev, result) => prev || result, 0)
-
-  return result || runSteps('Reinstall', [['yarn', 'install --network-timeout 10000']])
-}

package/src/actions/relint.ts

@@ -1,76 +0,0 @@
-import chalk from 'chalk'
-import type { ESLint } from 'eslint'
-
-import { runSteps, yarnWorkspaces } from '../lib/index.ts'
-
-export interface RelintParams {
-  incremental?: boolean
-  pkg?: string
-  verbose?: boolean
-}
-
-export interface RelintPackageParams {
-  pkg: string
-  verbose?: boolean
-}
-
-const dumpMessages = (lintResults: ESLint.LintResult[]) => {
-  const colors: ('white' | 'red' | 'yellow')[] = ['white', 'yellow', 'red']
-  const severity: string[] = ['none', 'warning', 'error']
-
-  for (const lintResult of lintResults) {
-    if (lintResult.messages.length > 0) {
-      console.log(chalk.gray(`${lintResult.filePath}`))
-      for (const message of lintResult.messages) {
-        console.log(
-          chalk.gray(`\t${message.line}:${message.column}`),
-          chalk[colors[message.severity]](`\t${severity[message.severity]}`),
-          chalk.white(`\t${message.message}`),
-          chalk.gray(`\t${message.ruleId}`),
-        )
-      }
-    }
-  }
-}
-
-export const relintPackage = ({ pkg }: RelintParams & Required<Pick<RelintParams, 'pkg'>>) => {
-  console.log(chalk.gray(`${'Relint'} [All-Packages]`))
-  const start = Date.now()
-
-  const result = runSteps('Relint [All-Packages]', [
-    ['yarn', ['workspace',
-      pkg,
-      'run',
-      'package-relint',
-    ]],
-  ])
-  console.log(chalk.gray(`${'Relinted in'} [${chalk.magenta(((Date.now() - start) / 1000).toFixed(2))}] ${chalk.gray('seconds')}`))
-  return result
-}
-
-export const relint = ({
-  pkg, verbose, incremental,
-}: RelintParams = {}) => {
-  return pkg
-    ? relintPackage({ pkg })
-    : relintAllPackages({ verbose, incremental })
-}
-
-export const relintAllPackages = ({ verbose = true, incremental }: RelintParams = {}) => {
-  console.log(chalk.gray(`${'Relint'} [All-Packages]`))
-  const start = Date.now()
-  const verboseOptions = verbose ? ['--verbose'] : ['--no-verbose']
-  const incrementalOptions = incremental ? ['--since', '-Ap'] : ['--parallel', '-Ap']
-
-  const result = runSteps(`${'Relint'}  [All-Packages]`, [
-    ['yarn', ['workspaces',
-      'foreach',
-      ...verboseOptions,
-      ...incrementalOptions,
-      'run',
-      'package-relint',
-    ]],
-  ])
-  console.log(chalk.gray(`Relinted in [${chalk.magenta(((Date.now() - start) / 1000).toFixed(2))}] ${chalk.gray('seconds')}`))
-  return result
-}

package/src/actions/retest.ts

@@ -1,8 +0,0 @@
-import { runSteps } from '../lib/index.ts'
-
-export const retest = () => {
-  return runSteps('Test', [
-    ['yarn', ['jest', '--clearCache']],
-    ['yarn', ['jest', '.']],
-  ])
-}