refactor: refactor deps updater

Author: zdm

lib/package.js

@@ -657,125 +657,107 @@ export default class Package {
 
         outdatedDependencies ||= {};
 
-        // add missed / linked deps
-        {
-            const linkedDependencies = await this.#getLinkedDependencies();
-
-            for ( const dependency of linkedDependencies.values() ) {
-                if ( !outdatedDependencies[ dependency.name ] ) {
-                    outdatedDependencies[ dependency.name ] = [];
-                }
-                else if ( !Array.isArray( outdatedDependencies[ dependency.name ] ) ) {
-                    outdatedDependencies[ dependency.name ] = [ outdatedDependencies[ dependency.name ] ];
-                }
-
-                if ( dependency.missed || ( linked && dependency.link ) ) {
-                    outdatedDependencies[ dependency.name ].push( {
-
-                        // XXX location
-                        "location": "-",
-                        "missed": dependency.missed,
-                        "linked": dependency.link,
-                    } );
-                }
-            }
-        }
-
-        var hasUpdates;
-
-        const updateDependencies = [];
+        const linkedDependencies = await this.#getLinkedDependencies(),
+            index = {};
 
+        // index dependencies
         for ( const name in outdatedDependencies ) {
-            let specs;
+            let dependencies;
 
             if ( Array.isArray( outdatedDependencies[ name ] ) ) {
-                specs = outdatedDependencies[ name ];
+                dependencies = outdatedDependencies[ name ];
             }
             else {
-                specs = [ outdatedDependencies[ name ] ];
+                dependencies = [ outdatedDependencies[ name ] ];
             }
 
-            const index = {};
-
-            for ( const spec of specs ) {
+            for ( const dependency of dependencies ) {
 
-                // group specs by id
-                const id = spec.location;
+                // group by id
+                const id = dependency.location;
 
                 index[ id ] ??= {
                     name,
-                    "current": spec.current,
-                    "wanted": spec.wanted,
-                    "latest": spec.latest,
-                    "location": spec.location,
+                    "current": dependency.current,
+                    "wanted": dependency.wanted,
+                    "latest": dependency.latest,
+                    "location": dependency.location,
                     "dependent": new Set(),
-                    "missed": spec.missed,
-                    "linked": spec.linked,
-                    "topLevel": this.dependencies.has( name ) && spec.location === path.join( this.root, "node_modules", name ),
+                    "topLevel": this.dependencies.has( name ) && dependency.location === path.join( this.root, "node_modules", name ),
                 };
 
-                index[ id ].dependent.add( spec.dependent );
+                index[ id ].dependent.add( dependency.dependent );
+
+                const linkedDependency = linkedDependencies.get( name );
+                if ( linkedDependency && linkedDependency.location === dependency.location ) {
+                    index[ id ].missed = linkedDependency.missed;
+                    index[ id ].linked = linkedDependency.linked;
+                }
             }
+        }
 
-            specs = Object.values( index ).map( spec => {
-                spec.dependent = [ ...spec.dependent ].sort().join( ", " );
+        // add missed deps
+        for ( const dependency of linkedDependencies.values() ) {
+            if ( !dependency.missed ) continue;
 
-                return spec;
-            } );
+            if ( !index[ dependency.location ] ) {
+                index[ dependency.location ] = dependency;
+            }
+        }
 
-            for ( const spec of specs ) {
+        var hasUpdates;
 
-                // outdated dependency
-                spec.outdated = spec.wanted !== spec.latest && new SemanticVersion( spec.latest ).gt( spec.wanted );
+        const updateDependencies = [];
 
-                // include installed, updatable deps by default
-                let include;
+        for ( const dependency of Object.values( index ) ) {
 
-                // linked
-                if ( spec.linked ) {
+            // outdated dependency
+            dependency.outdated = dependency.wanted !== dependency.latest && new SemanticVersion( dependency.latest ).gt( dependency.wanted );
 
-                    // XXX
-                    if ( linked ) {
-                        spec.updatable = true;
+            // include installed, updatable deps by default
+            let include;
 
-                        include = true;
-                    }
-                }
-                else {
-                    spec.updatable = spec.current !== spec.wanted;
+            // linked
+            if ( dependency.linked ) {
 
-                    if ( spec.updatable && spec.current ) {
-                        include = true;
-                    }
-                }
+                // XXX
+                if ( linked ) {
+                    dependency.updatable = true;
 
-                // include top-level outdated deps
-                if ( outdated && spec.outdated && spec.topLevel ) {
                     include = true;
                 }
+            }
+            else {
+                dependency.updatable = dependency.current !== dependency.wanted;
 
-                // include linked deps
-                if ( spec.linked ) {
+                if ( dependency.updatable && dependency.current ) {
                     include = true;
                 }
+            }
 
-                // include missed deps
-                if ( spec.missed ) {
-                    include = true;
-                }
+            // include top-level outdated deps
+            if ( outdated && dependency.outdated && dependency.topLevel ) {
+                include = true;
+            }
 
-                if ( !include ) continue;
+            // include linked deps
+            if ( dependency.linked ) {
+                include = true;
+            }
 
-                // updatable dependency
-                if ( spec.updatable ) {
-                    hasUpdates = true;
-                }
+            // include missed deps
+            if ( dependency.missed ) {
+                include = true;
+            }
 
-                updateDependencies.push( {
-                    name,
-                    ...spec,
-                } );
+            if ( !include ) continue;
+
+            // updatable dependency
+            if ( dependency.updatable ) {
+                hasUpdates = true;
             }
+
+            updateDependencies.push( dependency );
         }
 
         install = install && ( hasUpdates || reinstall );
@@ -798,6 +780,14 @@ export default class Package {
                             "title": ansi.hl( "DEPENDENCY" ),
                             "headerAlign": "center",
                             "headerValign": "end",
+                            format ( value ) {
+                                if ( value ) {
+                                    return [ ...value ].sort().join( ", " );
+                                }
+                                else {
+                                    return "-";
+                                }
+                            },
                         },
                         "dependent": {
                             "title": ansi.hl( "DEPENDENT" ),
@@ -1554,26 +1544,33 @@ export default class Package {
 
             return fs.promises
                 .readlink( location )
-                .then( link =>
+                .then( link => {
+
+                    // linked
                     dependencies.set( name, {
                         name,
                         location,
-                        link,
-                    } ) )
+                        "linked": link,
+                    } );
+                } )
                 .catch( e => {
 
-                    // not exists
-                    if ( e.code === "ENOENT" ) {
-                        dependencies.set( name, {
-                            name,
-                            location,
-                            "missed": true,
-                        } );
-                    }
-
-                    // other error
-                    else if ( e.code !== "EINVAL" ) {
-                        console.log( e );
+                    // not a link
+                    if ( e.code !== "EINVAL" ) {
+
+                        // missed
+                        if ( e.code === "ENOENT" ) {
+                            dependencies.set( name, {
+                                name,
+                                location,
+                                "missed": true,
+                            } );
+                        }
+
+                        // error
+                        else {
+                            console.log( e );
+                        }
                     }
                 } );
         } ) );