feat: locked version by default, new --include-locked option (#72)

Co-authored-by: jerrywu <[email protected]>
Co-authored-by: Anthony Fu <[email protected]>

README.md

@@ -72,6 +72,10 @@ taze --include lodash,webpack
 taze --include /react/ --exclude react-dom # regex is also supported
 ```
 
+### Lockedversion
+
+Locked (fixed version without `^` or `~`) packages are skipped by default, use `taze --include-locked` or `taze -l` to show them.
+
 ### Config file
 
 With `taze.config.js` file, you can configure the same options the command has.

src/cli.ts

@@ -77,6 +77,11 @@ function commonOptions(args: Argv<object>): Argv<CommonOptions> {
       describe: 'update only for dependencies',
       conflicts: ['dev'],
     })
+    .option('include-locked', {
+      alias: 'l',
+      type: 'boolean',
+      describe: 'include locked dependencies & devDependencies',
+    })
 }
 
 // eslint-disable-next-line no-unused-expressions

src/commands/check/interactive.ts

@@ -19,7 +19,7 @@ export async function promptInteractive(pkgs: PackageMeta[], options: CheckOptio
       if (i.latestVersionAvailable && !i.update) {
         i.interactiveChecked = false
         i.update = true
-        updateTargetVersion(i, i.latestVersionAvailable)
+        updateTargetVersion(i, i.latestVersionAvailable, undefined, options.includeLocked)
       }
     })
   })
@@ -166,7 +166,7 @@ export async function promptInteractive(pkgs: PackageMeta[], options: CheckOptio
           case 'right':
           case 'h':
           case 'l':
-            updateTargetVersion(dep, versions[index].version)
+            updateTargetVersion(dep, versions[index].version, undefined, options.includeLocked)
             renderer = listRenderer
             return true
         }

src/io/resolves.ts

@@ -101,10 +101,36 @@ export function getVersionOfRange(dep: ResolvedDepChange, range: RangeMode) {
   return getMaxSatisfying(versions, dep.currentVersion, range, tags)
 }
 
-export function updateTargetVersion(dep: ResolvedDepChange, version: string, forgiving = true) {
+export function updateTargetVersion(
+  dep: ResolvedDepChange,
+  version: string,
+  forgiving = true,
+  includeLocked = false,
+) {
+  const versionLocked = /^[0-9]+/.test(dep.currentVersion)
+  if (versionLocked && !includeLocked) {
+    dep.targetVersion = dep.currentVersion
+    dep.targetVersionTime = dep.currentVersionTime
+    dep.diff = null
+    dep.update = false
+    return
+  }
+
   dep.targetVersion = getPrefixedVersion(dep.currentVersion, version) || dep.currentVersion
   dep.targetVersionTime = dep.pkgData.time?.[version]
 
+  if (versionLocked && semver.eq(dep.currentVersion, dep.targetVersion)) {
+    // for example: `taze`/`taze -P` is default mode (and it matched from patch to minor)
+    // - but this mode will always ignore the locked pkgs
+    // - so we need to reset the target
+    const { versions, time = {}, tags } = dep.pkgData
+    const targetVersion = getMaxSatisfying(versions, dep.currentVersion, 'minor', tags)
+    if (targetVersion) {
+      dep.targetVersion = targetVersion
+      dep.targetVersionTime = time[dep.targetVersion]
+    }
+  }
+
   try {
     const current = semver.minVersion(dep.currentVersion)!
     const target = semver.minVersion(dep.targetVersion)!
@@ -176,7 +202,7 @@ export async function resolveDependency(
   }
 
   if (target)
-    updateTargetVersion(dep, target)
+    updateTargetVersion(dep, target, undefined, options.includeLocked)
   else
     dep.targetVersion = dep.currentVersion
 

src/types.ts

@@ -50,7 +50,7 @@ export interface CommonOptions {
   exclude?: string | string[]
   prod?: boolean
   dev?: boolean
-  loglevel: string
+  loglevel?: string
   failOnOutdated?: boolean
   silent?: boolean
   force?: boolean
@@ -71,6 +71,12 @@ export interface CheckOptions extends CommonOptions {
   install?: boolean
   update?: boolean
   global?: boolean
+  /**
+   * include locked dependencies & devDependencies
+   * @default false
+   * @description exclude the locked deps/devDeps by default
+   */
+  includeLocked?: boolean
 }
 
 export interface PackageMeta {

test/resolves.test.ts

@@ -45,42 +45,46 @@ it('resolveDependency', async () => {
   // major
   expect(false).toBe((await resolveDependency(makePkg(''), options, filter)).update)
   expect(false).toBe((await resolveDependency(makePkg('*'), options, filter)).update)
-  expect(true).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
+  expect(false).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('^4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('>4.0.0'), options, filter)).update)
 
   options.mode = 'minor'
   // minor
   expect(false).toBe((await resolveDependency(makePkg(''), options, filter)).update)
   expect(false).toBe((await resolveDependency(makePkg('*'), options, filter)).update)
-  expect(true).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
+  expect(false).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('^4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('>4.0.0'), options, filter)).update)
 
   options.mode = 'patch'
   // patch
   expect(false).toBe((await resolveDependency(makePkg(''), options, filter)).update)
   expect(false).toBe((await resolveDependency(makePkg('*'), options, filter)).update)
-  expect(true).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
+  expect(false).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('^4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('>4.0.0'), options, filter)).update)
 
   options.mode = 'latest'
   // latest
   expect(false).toBe((await resolveDependency(makePkg(''), options, filter)).update)
   expect(false).toBe((await resolveDependency(makePkg('*'), options, filter)).update)
-  expect(true).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
+  expect(false).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('^4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('>4.0.0'), options, filter)).update)
 
   options.mode = 'newest'
   // newest
   expect(false).toBe((await resolveDependency(makePkg(''), options, filter)).update)
   expect(false).toBe((await resolveDependency(makePkg('*'), options, filter)).update)
-  expect(true).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
+  expect(false).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('^4.0.0'), options, filter)).update)
   expect(true).toBe((await resolveDependency(makePkg('>4.0.0'), options, filter)).update)
 
+  // include locked
+  options.includeLocked = true
+  expect(true).toBe((await resolveDependency(makePkg('4.0.0'), options, filter)).update)
+
   expect((await resolveDependency(makePkg(''), options, filter)).targetVersion)
     .toMatch('')
   expect((await resolveDependency(makePkg('workspace:*'), options, filter)).targetVersion)