bare-module-traverse 1.2.5 → 1.3.0

package/README.md

@@ -10,36 +10,44 @@ npm i bare-module-traverse
 
 For synchronous traversal:
 
-``` js
+```js
 const traverse = require('bare-module-traverse')
 
-function readModule (url) {
+function readModule(url) {
   // Read `url` if it exists, otherwise `null`
 }
 
-function * listPrefix (url) {
+function* listPrefix(url) {
   // Yield URLs that have `url` as a prefix. The list may be empty.
 }
 
-for (const dependency of traverse(new URL('file:///directory/file.js'), readModule, listPrefix)) {
+for (const dependency of traverse(
+  new URL('file:///directory/file.js'),
+  readModule,
+  listPrefix
+)) {
   console.log(dependency)
 }
 ```
 
 For asynchronous traversal:
 
-``` js
+```js
 const traverse = require('bare-module-traverse')
 
-async function readModule (url) {
+async function readModule(url) {
   // Read `url` if it exists, otherwise `null`
 }
 
-async function * listPrefix (url) {
+async function* listPrefix(url) {
   // Yield URLs that have `url` as a prefix. The list may be empty.
 }
 
-for await (const dependency of traverse(new URL('file:///directory/file.js'), readModule, listPrefix)) {
+for await (const dependency of traverse(
+  new URL('file:///directory/file.js'),
+  readModule,
+  listPrefix
+)) {
   console.log(dependency)
 }
 ```
@@ -53,7 +61,7 @@ Traverse the module graph rooted at `url`, which must be a WHATWG `URL` instance
 Options include:
 
 ```js
-{
+options = {
   resolve: resolve.default
 }
 ```
@@ -65,7 +73,7 @@ Options supported by <https://github.com/holepunchto/bare-module-resolve> and <h
 Synchronously iterate the module graph. Each yielded dependency has the following shape:
 
 ```js
-{
+dependency = {
   url: URL,
   source: 'string' | Buffer, // Source as returned by `readModule()`
   imports: {
@@ -80,6 +88,8 @@ Asynchronously iterate the module graph. If `readModule` returns a promise or `l
 
 ### Resolution
 
+Module and addon resolution is configurable by providing a resolver function. A resolver function is a generator function that yields values matching the shapes defined by <https://github.com/holepunchto/bare-module-resolve#algorithm>. Several resolvers are provided out of the box to support the most common use cases.
+
 #### `resolve.module`
 
 Convenience export from <https://github.com/holepunchto/bare-module-resolve>.
@@ -94,15 +104,73 @@ The default resolver, which simply forwards to <https://github.com/holepunchto/b
 
 #### `resolve.bare`
 
-The Bare resolver, which matches the options used by the Bare module system.
+The Bare resolver, which matches the options used by the Bare module system. The resolver accepts the following additional options:
+
+```js
+options = {
+  platform: Bare.platform,
+  arch: Bare.arch,
+  simulator: false,
+  host: `${platform}-${arch}${simulator ? '-simulator' : ''}`,
+  target: [host]
+}
+```
+
+For single target traversal it is sufficient to pass `platform`, `arch`, `simulator`, and/or `host`. For multi target target traversal pass a list of `target` identifiers instead.
 
 #### `resolve.node`
 
-The Node.js resolver, which matches the options used by the Node.js module system.
+The Node.js resolver, which matches the options used by the Node.js module system. The resolver accepts the following additional options:
+
+```js
+options = {
+  platform: process.platform,
+  arch: process.arch,
+  simulator: false,
+  host: `${platform}-${arch}${simulator ? '-simulator' : ''}`,
+  target: [host]
+}
+```
+
+For single target traversal it is sufficient to pass `platform`, `arch`, `simulator`, and/or `host`. For multi target target traversal pass a list of `target` identifiers instead.
 
 ### Algorithm
 
-The following generator functions implement the traversal algorithm. To drive the generator functions, a loop like the following can be used:
+The following generator functions implement the traversal algorithm. The yielded values have the following shape:
+
+**Source module**
+
+```js
+next.value = {
+  module: URL
+}
+```
+
+**File prefix**
+
+```js
+next.value = {
+  prefix: URL
+}
+```
+
+**Dependency subgraph**
+
+```js
+next.value = {
+  children: URL
+}
+```
+
+**Dependency node**
+
+```js
+next.value = {
+  dependency: URL
+}
+```
+
+To drive the generator functions, a loop like the following can be used:
 
 ```js
 const queue = [traverse.module(url, source, artifacts, visited)]
@@ -116,11 +184,13 @@ while (queue.length > 0) {
     const value = next.value
 
     if (value.module) {
-      const source = /* Read `value.module` if it exists, otherwise `null` */;
+      // Read `value.module` if it exists, otherwise `null`
+      let source
 
       next = generator.next(source)
     } else if (value.prefix) {
-      const modules = /* List the modules that have `value.prefix` as a prefix */;
+      // List the modules that have `value.prefix` as a prefix
+      let modules
 
       next = generator.next(modules)
     } else {

package/index.js

@@ -1,10 +1,15 @@
-const { lookupPackageScope } = require('bare-module-resolve')
+const { lookupPackageScope, conditionMatches } = require('bare-module-resolve')
 const { lookupPrebuildsScope } = require('bare-addon-resolve')
 const lex = require('bare-module-lexer')
 const resolve = require('./lib/resolve')
 const errors = require('./lib/errors')
 
-module.exports = exports = function traverse (entry, opts, readModule, listPrefix) {
+module.exports = exports = function traverse(
+  entry,
+  opts,
+  readModule,
+  listPrefix
+) {
   if (typeof opts === 'function') {
     listPrefix = readModule
     readModule = opts
@@ -16,7 +21,7 @@ module.exports = exports = function traverse (entry, opts, readModule, listPrefi
   }
 
   return {
-    * [Symbol.iterator] () {
+    *[Symbol.iterator]() {
       const artifacts = { addons: [], assets: [] }
 
       const queue = [exports.module(entry, null, artifacts, new Set(), opts)]
@@ -51,7 +56,7 @@ module.exports = exports = function traverse (entry, opts, readModule, listPrefi
       return artifacts
     },
 
-    async * [Symbol.asyncIterator] () {
+    async *[Symbol.asyncIterator]() {
       const artifacts = { addons: [], assets: [] }
 
       const queue = [exports.module(entry, null, artifacts, new Set(), opts)]
@@ -88,51 +93,11 @@ module.exports = exports = function traverse (entry, opts, readModule, listPrefi
   }
 }
 
-function * defaultListPrefix () {}
-
-function addURL (array, url) {
-  let lo = 0
-  let hi = array.length - 1
-
-  while (lo <= hi) {
-    const mid = lo + ((hi - lo) >> 1)
-    const found = array[mid]
-
-    if (found.href === url.href) return
-
-    if (found.href < url.href) {
-      lo = mid + 1
-    } else {
-      hi = mid - 1
-    }
-  }
-
-  array.splice(lo, 0, url)
-}
-
-function removeURL (array, url) {
-  let lo = 0
-  let hi = array.length - 1
-
-  while (lo <= hi) {
-    const mid = lo + ((hi - lo) >> 1)
-    const found = array[mid]
-
-    if (found.href === url.href) break
-
-    if (found.href < url.href) {
-      lo = mid + 1
-    } else {
-      hi = mid - 1
-    }
-  }
-
-  if (array[lo].href === url.href) array.splice(lo, 1)
-}
+function* defaultListPrefix() {}
 
 exports.resolve = resolve
 
-exports.module = function * (url, source, artifacts, visited, opts = {}) {
+exports.module = function* (url, source, artifacts, visited, opts = {}) {
   const { resolutions = null } = opts
 
   if (visited.has(url.href)) return false
@@ -148,7 +113,16 @@ exports.module = function * (url, source, artifacts, visited, opts = {}) {
   visited.add(url.href)
 
   if (resolutions) {
-    if (yield * exports.preresolved(url, source, resolutions, artifacts, visited, opts)) {
+    if (
+      yield* exports.preresolved(
+        url,
+        source,
+        resolutions,
+        artifacts,
+        visited,
+        opts
+      )
+    ) {
       return true
     }
   }
@@ -161,18 +135,22 @@ exports.module = function * (url, source, artifacts, visited, opts = {}) {
     if (source !== null) {
       imports['#package'] = packageURL.href
 
-      yield { children: exports.package(packageURL, source, artifacts, visited, opts) }
+      yield {
+        children: exports.package(packageURL, source, artifacts, visited, opts)
+      }
+
+      break
     }
   }
 
-  yield * exports.imports(url, source, imports, artifacts, visited, opts)
+  yield* exports.imports(url, source, imports, artifacts, visited, opts)
 
   yield { dependency: { url, source, imports: compressImportsMap(imports) } }
 
   return true
 }
 
-exports.package = function * (url, source, artifacts, visited, opts = {}) {
+exports.package = function* (url, source, artifacts, visited, opts = {}) {
   if (visited.has(url.href)) return false
 
   visited.add(url.href)
@@ -187,7 +165,9 @@ exports.package = function * (url, source, artifacts, visited, opts = {}) {
     }
 
     if (info.assets) {
-      yield { children: exports.assets(info.assets, url, artifacts, visited, opts) }
+      yield {
+        children: exports.assets(info.assets, url, artifacts, visited, opts)
+      }
     }
 
     return true
@@ -196,7 +176,14 @@ exports.package = function * (url, source, artifacts, visited, opts = {}) {
   return false
 }
 
-exports.preresolved = function * (url, source, resolutions, artifacts, visited, opts = {}) {
+exports.preresolved = function* (
+  url,
+  source,
+  resolutions,
+  artifacts,
+  visited,
+  opts = {}
+) {
   const imports = resolutions[url.href]
 
   if (typeof imports !== 'object' || imports === null) return false
@@ -211,9 +198,13 @@ exports.preresolved = function * (url, source, resolutions, artifacts, visited,
         const url = new URL(entry)
 
         if (specifier === '#package') {
-          yield { children: exports.package(url, null, artifacts, visited, opts) }
+          yield {
+            children: exports.package(url, null, artifacts, visited, opts)
+          }
         } else {
-          yield { children: exports.module(url, null, artifacts, visited, opts) }
+          yield {
+            children: exports.module(url, null, artifacts, visited, opts)
+          }
         }
       } else {
         stack.unshift(...Object.values(entry))
@@ -226,103 +217,145 @@ exports.preresolved = function * (url, source, resolutions, artifacts, visited,
   return true
 }
 
-exports.imports = function * (parentURL, source, imports, artifacts, visited, opts = {}) {
-  const { resolve = exports.resolve.default, builtinProtocol = 'builtin:', linkedProtocol = 'linked:' } = opts
+exports.imports = function* (
+  parentURL,
+  source,
+  imports,
+  artifacts,
+  visited,
+  opts = {}
+) {
+  const {
+    resolve = exports.resolve.default,
+    builtinProtocol = 'builtin:',
+    linkedProtocol = 'linked:',
+    matchedConditions = []
+  } = opts
 
   let yielded = false
 
   for (const entry of lex(source).imports) {
-    const resolver = resolve(entry, parentURL, opts)
-
-    let next = resolver.next()
-    let resolved = false
     let specifier = entry.specifier
-    let key = 'default'
+    let condition = 'default'
 
     if (entry.type & lex.constants.ADDON) {
       specifier = specifier || '.'
-      key = 'addon'
+      condition = 'addon'
     } else if (entry.type & lex.constants.ASSET) {
-      key = 'asset'
+      condition = 'asset'
     }
 
+    matchedConditions.push(condition)
+
+    const resolver = resolve(entry, parentURL, { ...opts, matchedConditions })
+
+    let next = resolver.next()
+    let resolutions = 0
+
     while (next.done !== true) {
       const value = next.value
 
       if (value.package) {
         next = resolver.next(JSON.parse(yield { module: value.package }))
+      } else if (hasResolution(imports, specifier, matchedConditions)) {
+        next = resolver.next(false)
       } else {
         const url = value.resolution
 
-        if (url.protocol === builtinProtocol || url.protocol === linkedProtocol) {
-          if (key === 'addon') addURL(artifacts.addons, url)
-          else if (key === 'asset') addURL(artifacts.assets, url)
+        let resolved = false
 
-          imports[specifier] = { [key]: url.href, ...imports[specifier] }
+        if (
+          url.protocol === builtinProtocol ||
+          url.protocol === linkedProtocol
+        ) {
+          if (addResolution(imports, specifier, matchedConditions, url)) {
+            resolved = yielded = true
+          }
+        } else {
+          const source = yield { module: url }
 
-          resolved = yielded = true
+          if (source !== null) {
+            if (addResolution(imports, specifier, matchedConditions, url)) {
+              yield {
+                children: exports.module(url, source, artifacts, visited, opts)
+              }
 
-          break
+              resolved = yielded = true
+            }
+          }
         }
 
-        const source = yield { module: url }
-
-        if (source !== null) {
-          if (key === 'addon') addURL(artifacts.addons, url)
-          else if (key === 'asset') addURL(artifacts.assets, url)
+        if (resolved) {
+          if (condition === 'addon') addURL(artifacts.addons, url)
+          else if (condition === 'asset') addURL(artifacts.assets, url)
 
-          imports[specifier] = { [key]: url.href, ...imports[specifier] }
-
-          yield { children: exports.module(url, source, artifacts, visited, opts) }
-
-          resolved = yielded = true
-
-          break
+          resolutions++
         }
 
-        next = resolver.next()
+        next = resolver.next(resolved)
       }
     }
 
-    if (!resolved) {
-      switch (key) {
-        case 'addon':
-          throw errors.ADDON_NOT_FOUND(`Cannot find addon '${specifier}' imported from '${parentURL.href}'`)
-        case 'asset':
-          throw errors.ASSET_NOT_FOUND(`Cannot find asset '${specifier}' imported from '${parentURL.href}'`)
-        default:
-          throw errors.MODULE_NOT_FOUND(`Cannot find module '${specifier}' imported from '${parentURL.href}'`)
-      }
+    matchedConditions.pop()
+
+    if (resolutions === 0) {
+      throw errors.ADDON_NOT_FOUND(
+        `Cannot find ${condition === 'default' ? 'module' : condition} '${specifier}' imported from '${parentURL.href}'`
+      )
     }
   }
 
   return yielded
 }
 
-exports.prebuilds = function * (packageURL, artifacts, visited, opts = {}) {
-  const [prefix = null] = lookupPrebuildsScope(packageURL, opts)
+exports.prebuilds = function* (packageURL, artifacts, visited, opts = {}) {
+  const {
+    host = null, // Shorthand for single host resolution
+    hosts = host !== null ? [host] : [],
+    matchedConditions = []
+  } = opts
 
-  if (prefix === null) return false
+  const [prebuildsURL = null] = lookupPrebuildsScope(packageURL, opts)
+
+  if (prebuildsURL === null) return false
 
   let yielded = false
 
-  for (const url of yield { prefix }) {
-    const source = yield { module: url }
+  for (const host of hosts) {
+    const prefix = new URL(host + '/', prebuildsURL)
 
-    if (source !== null) {
-      addURL(artifacts.addons, url)
+    const conditions = host.split('-')
 
-      yield { children: exports.module(url, source, artifacts, visited, opts) }
+    matchedConditions.push(...conditions)
 
-      yielded = true
+    for (const url of yield { prefix }) {
+      const source = yield { module: url }
+
+      if (source !== null) {
+        addURL(artifacts.addons, url)
+
+        yield {
+          children: exports.module(url, source, artifacts, visited, opts)
+        }
+
+        yielded = true
+      }
     }
+
+    for (const _ of conditions) matchedConditions.pop()
   }
 
   return yielded
 }
 
-exports.assets = function * (patterns, parentURL, artifacts, visited, opts = {}) {
-  const matches = yield * exports.patternMatches(patterns, parentURL, [], opts)
+exports.assets = function* (
+  patterns,
+  parentURL,
+  artifacts,
+  visited,
+  opts = {}
+) {
+  const matches = yield* exports.patternMatches(patterns, parentURL, [], opts)
 
   let yielded = false
 
@@ -341,8 +374,13 @@ exports.assets = function * (patterns, parentURL, artifacts, visited, opts = {})
   return yielded
 }
 
-exports.patternMatches = function * (pattern, parentURL, matches, opts = {}) {
-  const { conditions = [] } = opts
+exports.patternMatches = function* patternMatches(
+  pattern,
+  parentURL,
+  matches,
+  opts = {}
+) {
+  const { conditions = [], matchedConditions = [] } = opts
 
   if (typeof pattern === 'string') {
     let patternNegate = false
@@ -378,24 +416,127 @@ exports.patternMatches = function * (pattern, parentURL, matches, opts = {}) {
     }
   } else if (Array.isArray(pattern)) {
     for (const patternValue of pattern) {
-      yield * exports.patternMatches(patternValue, parentURL, matches, opts)
+      yield* patternMatches(patternValue, parentURL, matches, opts)
     }
   } else if (typeof pattern === 'object' && pattern !== null) {
-    const keys = Object.keys(pattern)
-
-    for (const p of keys) {
-      if (p === 'default' || conditions.includes(p)) {
-        const patternValue = pattern[p]
-
-        return yield * exports.patternMatches(patternValue, parentURL, matches, opts)
+    let yielded = false
+
+    for (const [condition, patternValue, subset] of conditionMatches(
+      pattern,
+      conditions,
+      opts
+    )) {
+      matchedConditions.push(condition)
+
+      if (
+        yield* patternMatches(patternValue, parentURL, matches, {
+          ...opts,
+          conditions: subset
+        })
+      ) {
+        yielded = true
       }
+
+      matchedConditions.pop()
     }
+
+    if (yielded) return true
   }
 
   return matches
 }
 
-function compressImportsMap (imports) {
+function addURL(array, url) {
+  let lo = 0
+  let hi = array.length - 1
+
+  while (lo <= hi) {
+    const mid = lo + ((hi - lo) >> 1)
+    const found = array[mid]
+
+    if (found.href === url.href) return
+
+    if (found.href < url.href) {
+      lo = mid + 1
+    } else {
+      hi = mid - 1
+    }
+  }
+
+  array.splice(lo, 0, url)
+}
+
+function removeURL(array, url) {
+  let lo = 0
+  let hi = array.length - 1
+
+  while (lo <= hi) {
+    const mid = lo + ((hi - lo) >> 1)
+    const found = array[mid]
+
+    if (found.href === url.href) break
+
+    if (found.href < url.href) {
+      lo = mid + 1
+    } else {
+      hi = mid - 1
+    }
+  }
+
+  if (array[lo].href === url.href) array.splice(lo, 1)
+}
+
+function hasResolution(imports, specifier, conditions) {
+  if (specifier in imports === false) return false
+
+  let current = imports[specifier]
+
+  for (const key of conditions) {
+    if (key in current === false || typeof current[key] !== 'object') {
+      return false
+    }
+
+    current = current[key]
+  }
+
+  return true
+}
+
+function addResolution(imports, specifier, conditions, url) {
+  imports[specifier] = imports[specifier] || {}
+
+  let current = imports[specifier]
+
+  for (let i = 0, n = conditions.length - 1; i < n; i++) {
+    const key = conditions[i]
+
+    if (key in current === false) {
+      current[key] = {}
+    } else if (typeof current[key] !== 'object') {
+      current[key] = { default: current[key] }
+    }
+
+    current = current[key]
+  }
+
+  const last = conditions[conditions.length - 1]
+
+  if (last in current) return false
+
+  current[last] = url.href
+
+  if ('default' in current) {
+    const value = current.default
+
+    delete current.default
+
+    current.default = value
+  }
+
+  return true
+}
+
+function compressImportsMap(imports) {
   const entries = []
 
   for (const entry of Object.entries(imports)) {
@@ -407,7 +548,7 @@ function compressImportsMap (imports) {
   return Object.fromEntries(entries)
 }
 
-function compressImportsMapEntry (resolved) {
+function compressImportsMapEntry(resolved) {
   if (typeof resolved === 'string') return resolved
 
   let entries = []
@@ -421,13 +562,11 @@ function compressImportsMapEntry (resolved) {
     if (entry[0] === 'default') primary = entry[1]
   }
 
-  entries = entries.filter(([condition, resolved]) => condition === 'default' || resolved !== primary)
+  entries = entries.filter(
+    ([condition, resolved]) => condition === 'default' || resolved !== primary
+  )
 
-  if (entries.length === 1) {
-    const [condition, resolved] = entries[0]
-
-    if (condition === 'default') return resolved
-  }
+  if (entries.length === 1) return entries[0][1]
 
   return Object.fromEntries(entries)
 }

package/lib/errors.js

@@ -1,5 +1,5 @@
 module.exports = class ModuleTraverseError extends Error {
-  constructor (msg, code, fn = ModuleTraverseError) {
+  constructor(msg, code, fn = ModuleTraverseError) {
     super(`${code}: ${msg}`)
     this.code = code
 
@@ -8,19 +8,31 @@ module.exports = class ModuleTraverseError extends Error {
     }
   }
 
-  get name () {
+  get name() {
     return 'ModuleTraverseError'
   }
 
-  static MODULE_NOT_FOUND (msg) {
-    return new ModuleTraverseError(msg, 'MODULE_NOT_FOUND', ModuleTraverseError.MODULE_NOT_FOUND)
+  static MODULE_NOT_FOUND(msg) {
+    return new ModuleTraverseError(
+      msg,
+      'MODULE_NOT_FOUND',
+      ModuleTraverseError.MODULE_NOT_FOUND
+    )
   }
 
-  static ADDON_NOT_FOUND (msg) {
-    return new ModuleTraverseError(msg, 'ADDON_NOT_FOUND', ModuleTraverseError.ADDON_NOT_FOUND)
+  static ADDON_NOT_FOUND(msg) {
+    return new ModuleTraverseError(
+      msg,
+      'ADDON_NOT_FOUND',
+      ModuleTraverseError.ADDON_NOT_FOUND
+    )
   }
 
-  static ASSET_NOT_FOUND (msg) {
-    return new ModuleTraverseError(msg, 'ASSET_NOT_FOUND', ModuleTraverseError.ASSET_NOT_FOUND)
+  static ASSET_NOT_FOUND(msg) {
+    return new ModuleTraverseError(
+      msg,
+      'ASSET_NOT_FOUND',
+      ModuleTraverseError.ASSET_NOT_FOUND
+    )
   }
 }

package/lib/resolve/bare.js

@@ -9,32 +9,41 @@ module.exports = function (entry, parentURL, opts = {}) {
     platform = runtime.platform,
     arch = runtime.arch,
     simulator = false,
-    host = `${platform}-${arch}${simulator ? '-simulator' : ''}`
+    host = `${platform}-${arch}${simulator ? '-simulator' : ''}`,
+    target = [host]
   } = opts
 
   let extensions
-  let conditions = ['bare', 'node', platform, arch]
-
-  if (simulator) conditions = [...conditions, 'simulator']
+  let conditions = target.map((host) => ['bare', 'node', ...host.split('-')])
 
   if (entry.type & lex.constants.ADDON) {
     extensions = linked ? [] : ['.bare', '.node']
-    conditions = ['addon', ...conditions]
-
-    return resolve.addon(entry.specifier || '.', parentURL, { extensions, conditions, host, linked, ...opts })
+    conditions = conditions.map((conditions) => ['addon', ...conditions])
+
+    return resolve.addon(entry.specifier || '.', parentURL, {
+      extensions,
+      conditions,
+      hosts: target,
+      linked,
+      ...opts
+    })
   }
 
   if (entry.type & lex.constants.ASSET) {
-    conditions = ['asset', ...conditions]
+    conditions = conditions.map((conditions) => ['asset', ...conditions])
   } else {
     extensions = ['.js', '.cjs', '.mjs', '.json', '.bare', '.node']
 
     if (entry.type & lex.constants.REQUIRE) {
-      conditions = ['require', ...conditions]
+      conditions = conditions.map((conditions) => ['require', ...conditions])
     } else if (entry.type & lex.constants.IMPORT) {
-      conditions = ['import', ...conditions]
+      conditions = conditions.map((conditions) => ['import', ...conditions])
     }
   }
 
-  return resolve.module(entry.specifier, parentURL, { extensions, conditions, ...opts })
+  return resolve.module(entry.specifier, parentURL, {
+    extensions,
+    conditions,
+    ...opts
+  })
 }

package/lib/resolve/node.js

@@ -8,27 +8,39 @@ module.exports = function (entry, parentURL, opts = {}) {
     platform = runtime.platform,
     arch = runtime.arch,
     simulator = false,
-    host = `${platform}-${arch}${simulator ? '-simulator' : ''}`
+    host = `${platform}-${arch}${simulator ? '-simulator' : ''}`,
+    target = [host]
   } = opts
 
   let extensions
-  let conditions = ['node', platform, arch]
-
-  if (simulator) conditions = [...conditions, 'simulator']
+  let conditions
 
   if (entry.type & lex.constants.ADDON) {
     extensions = ['.node']
-    conditions = ['addon', ...conditions]
-
-    return resolve.addon(entry.specifier || '.', parentURL, { extensions, conditions, host, ...opts })
+    conditions = target.map((host) => ['node', 'addon', ...host.split('-')])
+
+    return resolve.addon(entry.specifier || '.', parentURL, {
+      extensions,
+      conditions,
+      host,
+      ...opts
+    })
   }
 
-  if (entry.type & lex.constants.REQUIRE) {
+  if (entry.type & lex.constants.ASSET) {
+    conditions = ['node', 'asset']
+  } else if (entry.type & lex.constants.REQUIRE) {
     extensions = ['.js', '.json', '.node']
     conditions = ['node', 'require']
   } else if (entry.type & lex.constants.IMPORT) {
     conditions = ['node', 'import']
+  } else {
+    conditions = ['node']
   }
 
-  return resolve.module(entry.specifier, parentURL, { extensions, conditions, ...opts })
+  return resolve.module(entry.specifier, parentURL, {
+    extensions,
+    conditions,
+    ...opts
+  })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-module-traverse",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "Low-level module graph traversal for Bare",
   "exports": {
     ".": "./index.js",
@@ -21,7 +21,10 @@
     }
   },
   "scripts": {
-    "test": "standard && bare test.js"
+    "test": "npm run lint && npm run test:bare && npm run test:node",
+    "test:bare": "bare test.js",
+    "test:node": "node test.js",
+    "lint": "prettier . --check"
   },
   "repository": {
     "type": "git",
@@ -40,6 +43,7 @@
   },
   "devDependencies": {
     "brittle": "^3.2.1",
-    "standard": "^17.0.0"
+    "prettier": "^3.4.2",
+    "prettier-config-standard": "^7.0.0"
   }
 }