fix: ls

Author: milaninfy

lib/commands/ls.js

@@ -1,8 +1,7 @@
 const { resolve, relative, sep } = require('node:path')
 const archy = require('archy')
-const { breadth } = require('treeverse')
 const npa = require('npm-package-arg')
-const { output } = require('proc-log')
+const { output, log } = require('proc-log')
 const ArboristWorkspaceCmd = require('../arborist-cmd.js')
 const localeCompare = require('@isaacs/string-locale-compare')('en')
 
@@ -20,6 +19,72 @@ const _problems = Symbol('problems')
 const _required = Symbol('required')
 const _type = Symbol('type')
 
+function bfs (tree, visit, getChildren) {
+  const queue = [tree]
+  let finalResult = null
+  const seenNodes = new Map()
+  const problems = new Set()
+
+  seenNodes.set(tree.path, tree)
+  while (queue.length > 0) {
+    const node = queue.shift()
+
+    const result = visit(node, problems)
+    if (!finalResult) {
+      finalResult = result
+    }
+    queue.push(...getChildren(node, result, seenNodes))
+  }
+  return [finalResult, seenNodes, problems]
+}
+
+const deepCopyNodes = (nodes) => {
+  return nodes.map(child => {
+    const copiedChild = { ...child }
+    if (child.nodes && Array.isArray(child.nodes)) {
+      copiedChild.nodes = deepCopyNodes(child.nodes)
+    }
+    return copiedChild
+  })
+}
+
+function dfs (
+  node,
+  getChildren,
+  visit,
+  seenNodes = new Map(),
+  problems = new Set(),
+  cache = new Map(),
+  encounterCount = new Map()
+) {
+  // Track the number of encounters for the current node
+  // Why because we want to start storing after the node is identified as a deduped edge
+  const count = (encounterCount.get(node.path) || 0) + 1
+  encounterCount.set(node.path, count)
+
+  // Start caching only after the third encounter
+  if (cache.has(node.path)) {
+    return [cache.get(node.path), seenNodes, problems]
+  }
+
+  const result = visit(node, problems)
+  if (count > 1) {
+    cache.set(node.path, result)
+  }
+
+  // Get children of current node
+  const children = getChildren(node, result, seenNodes)
+
+  // Recurse on each child
+  for (const child of children) {
+    const [cResult] = dfs(child, getChildren, visit, seenNodes, problems, cache, encounterCount)
+    result[_include] = result[_include] || cResult[_include]
+    cResult[_include] && result.nodes.push(cResult)
+  }
+
+  return [result, seenNodes, problems]
+}
+
 class LS extends ArboristWorkspaceCmd {
   static description = 'List installed packages'
   static name = 'ls'
@@ -105,94 +170,80 @@ class LS extends ArboristWorkspaceCmd {
       return true
     }
 
-    const seenItems = new Set()
-    const seenNodes = new Map()
-    const problems = new Set()
+    const getChildren = (node, nodeResult, seenNodes) => {
+      const seenPaths = new Set()
+      const workspace = node.isWorkspace
+      const currentDepth = workspace ? 0 : node[_depth]
+      const target = (node.target)?.edgesOut
+
+      const shouldSkipChildren =
+       (currentDepth > depthToPrint)
+        || nodeResult?.isCircular
+
+      return (shouldSkipChildren || !target)
+        ? []
+        : [...target.values()]
+          .filter(filterBySelectedWorkspaces)
+          .filter(currentDepth === 0 ? filterByEdgesTypes({
+            link,
+            omit,
+          }) : () => true)
+          .map(mapEdgesToNodes({ seenPaths }))
+          .concat(appendExtraneousChildren({ node, seenPaths }))
+          .sort(sortAlphabetically)
+          .map(augmentNodesWithMetadata({
+            args,
+            currentDepth,
+            nodeResult,
+            seenNodes,
+          }))
+    }
+
+    const visit = (node, problems) => {
+      node[_problems] = getProblems(node, { global })
 
+      const item = json
+        ? getJsonOutputItem(node, { global, long })
+        : parseable
+          ? {}
+          : getHumanOutputItem(node, { args, chalk, global, long })
+
+      // loop through list of node problems to add them to global list
+      if (node[_include]) {
+        for (const problem of node[_problems]) {
+          problems.add(problem)
+        }
+      }
+
+      item.traversePath = (node[_parent]?.traversePath || []).concat([node.realpath + '-' + node.pkgid])
+
+      if (node[_parent]?.traversePath?.includes(node.realpath + '-' + node.pkgid)) {
+        item.isCircular = true
+      }
+
+      // return a promise so we don't blow the stack
+      return item
+    }
     // defines special handling of printed depth when filtering with args
     const filterDefaultDepth = depth === null ? Infinity : depth
     const depthToPrint = (all || args.length)
       ? filterDefaultDepth
       : (depth || 0)
 
     // add root node of tree to list of seenNodes
-    seenNodes.set(tree.path, tree)
-
-    // tree traversal happens here, using treeverse.breadth
-    const result = await breadth({
-      tree,
-      // recursive method, `node` is going to be the current elem (starting from
-      // the `tree` obj) that was just visited in the `visit` method below
-      // `nodeResult` is going to be the returned `item` from `visit`
-      getChildren (node, nodeResult) {
-        const seenPaths = new Set()
-        const workspace = node.isWorkspace
-        const currentDepth = workspace ? 0 : node[_depth]
-        const target = (node.target)?.edgesOut
-
-        const shouldSkipChildren =
-         (currentDepth > depthToPrint)
-          || nodeResult?.isCircular
-
-        return (shouldSkipChildren || !target)
-          ? []
-          : [...target.values()]
-            .filter(filterBySelectedWorkspaces)
-            .filter(currentDepth === 0 ? filterByEdgesTypes({
-              link,
-              omit,
-            }) : () => true)
-            .map(mapEdgesToNodes({ seenPaths }))
-            .concat(appendExtraneousChildren({ node, seenPaths }))
-            .sort(sortAlphabetically)
-            .map(augmentNodesWithMetadata({
-              args,
-              currentDepth,
-              nodeResult,
-              seenNodes,
-            }))
-      },
-      // visit each `node` of the `tree`, returning an `item` - these are
-      // the elements that will be used to build the final output
-      visit (node) {
-        node[_problems] = getProblems(node, { global })
-
-        const item = json
-          ? getJsonOutputItem(node, { global, long })
-          : parseable
-            ? {}
-            : getHumanOutputItem(node, { args, chalk, global, long })
-
-        // loop through list of node problems to add them to global list
-        if (node[_include]) {
-          for (const problem of node[_problems]) {
-            problems.add(problem)
-          }
-        }
-
-        item.traversePath = (node[_parent]?.traversePath || []).concat([node.realpath + '-' + node.pkgid])
 
-        if (node[_parent]?.traversePath?.includes(node.realpath + '-' + node.pkgid)) {
-          item.isCircular = true
-        }
-
-        seenItems.add(item)
-
-        // return a promise so we don't blow the stack
-        return Promise.resolve(item)
-      },
-    })
+    const [result, seenNodes, problems] = dfs(tree, getChildren, visit)
 
     // handle the special case of a broken package.json in the root folder
     const [rootError] = tree.errors.filter(e =>
       e.code === 'EJSONPARSE' && e.path === resolve(path, 'package.json'))
 
     if (json) {
-      output.buffer(jsonOutput({ path, problems, result, rootError, seenItems }))
+      output.buffer(jsonOutput({ path, problems, result, rootError }))
     } else {
       output.standard(parseable
         ? parseableOutput({ seenNodes, global, long })
-        : humanOutput({ chalk, result, seenItems, unicode })
+        : humanOutput({ chalk, result, unicode })
       )
     }
 
@@ -275,19 +326,19 @@ const getProblems = (node, { global }) => {
 // annotates _parent and _include metadata into the resulting
 // item obj allowing for filtering out results during output
 const augmentItemWithIncludeMetadata = (node, item) => {
-  item[_parent] = node[_parent]
-  item[_include] = node[_include]
+  // item[_parent] = node[_parent]
+  // item[_include] = node[_include]
 
   // append current item to its parent.nodes which is the
   // structure expected by archy in order to print tree
-  if (node[_include]) {
-    // includes all ancestors of included node
-    let p = node[_parent]
-    while (p) {
-      p[_include] = true
-      p = p[_parent]
-    }
-  }
+  // if (node[_include]) {
+  //   // includes all ancestors of included node
+  //   let p = node[_parent]
+  //   while (p) {
+  //     p[_include] = true
+  //     p = p[_parent]
+  //   }
+  // }
 
   return item
 }
@@ -351,7 +402,7 @@ const getHumanOutputItem = (node, { args, chalk, global, long }) => {
     (node.isLink ? ` -> ${relativePrefix}${targetLocation}` : '') +
     (long ? `\n${node.package.description || ''}` : '')
 
-  return augmentItemWithIncludeMetadata(node, { label, nodes: [] })
+  return ({ label, nodes: [], [_include]: node[_include], [_parent]: node[_parent] })
 }
 
 const getJsonOutputItem = (node, { global, long }) => {
@@ -520,18 +571,18 @@ const augmentNodesWithMetadata = ({
   return node
 }
 
-const sortAlphabetically = ({ pkgid: a }, { pkgid: b }) => localeCompare(a, b)
+const sortAlphabetically = ({ pkgid: a }, { pkgid: b }) => localeCompare(b, a)
 
 const humanOutput = ({ chalk, result, seenItems, unicode }) => {
   // we need to traverse the entire tree in order to determine which items
   // should be included (since a nested transitive included dep will make it
   // so that all its ancestors should be displayed)
   // here is where we put items in their expected place for archy output
-  for (const item of seenItems) {
-    if (item[_include] && item[_parent]) {
-      item[_parent].nodes.push(item)
-    }
-  }
+  // for (const item of seenItems) {
+  //   if (item[_include] && item[_parent]) {
+  //     item[_parent].nodes.push(item)
+  //   }
+  // }
 
   if (!result.nodes.length) {
     result.nodes = ['(empty)']