bare-module-traverse 2.6.0 → 2.7.1

package/index.d.ts

@@ -3,9 +3,10 @@ import Buffer from 'bare-buffer'
 import {
   type ConditionalSpecifier,
   type ImportsMap,
-  type ResolutionsMap
+  type ResolutionsMap,
+  type ResolveOptions as ModuleResolveOptions
 } from 'bare-module-resolve'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
 import { type Import, type Export } from 'bare-module-lexer'
 
 interface Dependency {
@@ -41,6 +42,8 @@ type AliasableExtension =
   | '.bin'
   | '.txt'
 
+interface ResolveOptions extends ModuleResolveOptions, AddonResolveOptions {}
+
 interface TraverseOptions extends ResolveOptions {
   /**
    * The type to assume for a module that has no type of its own, such as one
@@ -71,6 +74,12 @@ interface TraverseOptions extends ResolveOptions {
    * system; a tool that only links wants the error.
    */
   deferUnresolved?: boolean
+  /**
+   * The URL the entry is mounted at when it is a bundle, for consumers that
+   * load it with an explicit mount. The addons and assets it declares resolve
+   * relative to this. Defaults to the URL of the entry itself.
+   */
+  mount?: URL | string
 }
 
 /**

package/index.js

@@ -1,3 +1,4 @@
+const Bundle = require('bare-bundle')
 const { lookupPackageScope, conditionMatches } = require('bare-module-resolve')
 const lex = require('bare-module-lexer')
 const MIME = require('bare-mime')
@@ -98,7 +99,7 @@ module.exports = exports = function traverse(
       }
 
       while (queue.length > 0 || deferred.length > 0) {
-        yield* drive(queue.length > 0 ? queue.pop() : deferred.shift())
+        yield* drive(queue.length > 0 ? queue.shift() : deferred.shift())
       }
 
       return artifacts
@@ -160,7 +161,7 @@ module.exports = exports = function traverse(
       }
 
       while (queue.length > 0 || deferred.length > 0) {
-        yield* drive(queue.length > 0 ? queue.pop() : deferred.shift())
+        yield* drive(queue.length > 0 ? queue.shift() : deferred.shift())
       }
 
       return artifacts
@@ -194,12 +195,20 @@ exports.alias = function alias(url, opts = {}) {
 exports.module = function* (url, source, attributes, artifacts, visited, opts = {}) {
   attributes = attributes || {}
 
+  // The mount only applies to the module the traversal starts from.
+  const { mount } = opts
+
+  if (mount !== undefined) opts = { ...opts, mount: undefined }
+
   if (opts.contexts === undefined) opts = { ...opts, contexts: new Map() }
   if (opts.addonContexts === undefined) opts = { ...opts, addonContexts: new Map() }
+  if (opts.resolvedImports === undefined) opts = { ...opts, resolvedImports: new Map() }
 
   // The host and WASI attributes set the context that the addons of the module
   // and everything it imports load in. A graph is walked again for each context
-  // it is imported under, even where it was visited before.
+  // it is imported under, even where it was visited before. The conditions of
+  // the host are added to those that may be targeted, so that the order of the
+  // conditions in a package still decides between them and the native ones.
   if (attributes.host !== undefined || attributes.wasi !== undefined) {
     const { addonHost = null, addonWASI = null } = opts
 
@@ -209,7 +218,11 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     if (host !== addonHost || wasi !== addonWASI) {
       opts = { ...opts, addonHost: host, addonWASI: wasi }
 
-      visited = visitedFor(opts.contexts, contextKey(host, wasi))
+      if (host !== addonHost) {
+        opts.conditions = withConditions(opts.conditions, host.split('-'))
+      }
+
+      visited = visitedFor(opts.contexts, host, wasi)
     }
   }
 
@@ -255,9 +268,26 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     }
   }
 
-  if (resolutions) {
+  // A bundle declares its own artifacts, whether or not its imports have been
+  // resolved before.
+  if (
+    asset === false &&
+    artifacts !== null &&
+    moduleType(url, attributes, null, opts) === constants.BUNDLE
+  ) {
+    addBundleArtifacts(source, mountFor(url, mount), artifacts)
+  }
+
+  // A module resolves its imports once, however many contexts it is loaded in,
+  // so a context that reaches it after another walks what the other resolved.
+  // The addons that are reached are then checked against the context.
+  const resolved = opts.resolvedImports.get(url.href)
+
+  const preresolved = resolved === undefined ? resolutions : { [url.href]: resolved }
+
+  if (preresolved) {
     if (
-      yield* exports.preresolved(url, source, attributes, resolutions, artifacts, visited, opts)
+      yield* exports.preresolved(url, source, attributes, preresolved, artifacts, visited, opts)
     ) {
       return true
     }
@@ -313,6 +343,10 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     }
   }
 
+  const compressed = compressImportsMap(imports)
+
+  opts.resolvedImports.set(url.href, compressed)
+
   yield {
     dependency: withWASI(
       {
@@ -320,7 +354,7 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
         source,
         type,
         naturalType,
-        imports: compressImportsMap(imports),
+        imports: compressed,
         lexer
       },
       opts
@@ -767,16 +801,22 @@ function addonHostForAttribute(host) {
   throw errors.UNKNOWN_ADDON_HOST(`Addon host '${host}' is not supported`)
 }
 
-function contextKey(host, wasi) {
-  return JSON.stringify([host, wasi])
+function withConditions(conditions = [], added) {
+  if (conditions.every((condition) => typeof condition === 'string')) {
+    return [...conditions, ...added]
+  }
+
+  return conditions.map((subset) => withConditions(subset, added))
 }
 
-function visitedFor(contexts, key) {
-  let visited = contexts.get(key)
+function visitedFor(contexts, host, wasi) {
+  const key = JSON.stringify([host, wasi])
 
-  if (visited === undefined) contexts.set(key, (visited = new Set()))
+  let context = contexts.get(key)
 
-  return visited
+  if (context === undefined) contexts.set(key, (context = { host, wasi, visited: new Set() }))
+
+  return context.visited
 }
 
 function withWASI(dependency, opts) {
@@ -829,6 +869,19 @@ exports.assertAddonContext = function assertAddonContext(url, scope, context, ad
   }
 }
 
+function addBundleArtifacts(source, mount, artifacts) {
+  const bundle = Bundle.from(source).mount(mount)
+
+  for (const href of bundle.addons) addURL(artifacts.addons, new URL(href))
+  for (const href of bundle.assets) addURL(artifacts.assets, new URL(href))
+}
+
+function mountFor(url, mount) {
+  const href = mount === undefined ? url.href : new URL(mount).href
+
+  return href.endsWith('/') ? href : href + '/'
+}
+
 function isJavaScript(type) {
   return type === constants.SCRIPT || type === constants.MODULE
 }

package/lib/conditions.js

@@ -0,0 +1,23 @@
+// One set of conditions for each host, each with the targeted conditions. A
+// host whose conditions are targeted in every set already has its resolutions,
+// so it gets no set of its own.
+module.exports = function conditions(base, hosts, targets) {
+  const subsets = leaves(targets)
+
+  const own = hosts.filter(
+    (host) =>
+      !subsets.every((subset) => host.split('-').every((condition) => subset.includes(condition)))
+  )
+
+  return (own.length > 0 ? own : hosts).flatMap((host) =>
+    subsets.map((subset) => [...base, ...host.split('-'), ...subset])
+  )
+}
+
+// Conditions nest to any depth and are tried depth first, so they match as
+// their innermost lists would in order.
+function leaves(conditions) {
+  if (conditions.every((condition) => typeof condition === 'string')) return [conditions]
+
+  return conditions.flatMap(leaves)
+}

package/lib/resolve/bare.d.ts

@@ -1,10 +1,17 @@
+import URL from 'bare-url'
 import { type Import } from 'bare-module-lexer'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type Conditions, type ResolveOptions as ModuleResolveOptions } from 'bare-module-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
 
-interface BareResolveOptions extends ResolveOptions {
+interface BareResolveOptions extends ModuleResolveOptions, AddonResolveOptions {
   linked?: boolean
   host?: string
   hosts?: string[]
+  /**
+   * The conditions that may be targeted in addition to those of each host,
+   * either a list or nested lists to try in turn.
+   */
+  conditions?: Conditions
 }
 
 /**

package/lib/resolve/bare.js

@@ -1,13 +1,19 @@
 const lex = require('bare-module-lexer')
 const resolve = require('../resolve')
 const runtime = require('../runtime')
+const hostConditions = require('../conditions')
 
 module.exports = function (entry, parentURL, opts = {}) {
-  const { linked = false, host = runtime.host, hosts = [host, 'wasi-wasm32'] } = opts
+  const {
+    linked = false,
+    host = runtime.host,
+    hosts = [host, 'wasi-wasm32'],
+    conditions: targets = []
+  } = opts
 
   let directories = false
   let extensions
-  let conditions = hosts.map((host) => ['bare', 'node', ...host.split('-')])
+  let conditions = hostConditions(['bare', 'node'], hosts, targets)
 
   if (entry.type & lex.constants.ADDON) {
     extensions = linked ? [] : ['.bare', '.node']

package/lib/resolve/default.d.ts

@@ -1,5 +1,9 @@
+import URL from 'bare-url'
 import { type Import } from 'bare-module-lexer'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type ResolveOptions as ModuleResolveOptions } from 'bare-module-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
+
+interface ResolveOptions extends ModuleResolveOptions, AddonResolveOptions {}
 
 /**
  * @param entry - The import to resolve, as produced by `bare-module-lexer`.

package/lib/resolve/node.d.ts

@@ -1,9 +1,16 @@
+import URL from 'bare-url'
 import { type Import } from 'bare-module-lexer'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type Conditions, type ResolveOptions as ModuleResolveOptions } from 'bare-module-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
 
-interface NodeResolveOptions extends ResolveOptions {
+interface NodeResolveOptions extends ModuleResolveOptions, AddonResolveOptions {
   host?: string
   hosts?: string[]
+  /**
+   * The conditions that may be targeted in addition to those of each host,
+   * either a list or nested lists to try in turn.
+   */
+  conditions?: Conditions
 }
 
 /**

package/lib/resolve/node.js

@@ -1,13 +1,14 @@
 const lex = require('bare-module-lexer')
 const resolve = require('../resolve')
 const runtime = require('../runtime')
+const hostConditions = require('../conditions')
 
 module.exports = function (entry, parentURL, opts = {}) {
-  const { host = runtime.host, hosts = [host] } = opts
+  const { host = runtime.host, hosts = [host], conditions: targets = [] } = opts
 
   let directories = false
   let extensions
-  let conditions = hosts.map((host) => ['node', ...host.split('-')])
+  let conditions = hostConditions(['node'], hosts, targets)
 
   if (entry.type & lex.constants.ADDON) {
     extensions = ['.node']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-module-traverse",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "description": "Low-level module graph traversal for Bare",
   "exports": {
     ".": {
@@ -55,6 +55,7 @@
   "homepage": "https://github.com/holepunchto/bare-module-traverse#readme",
   "dependencies": {
     "bare-addon-resolve": "^1.5.0",
+    "bare-bundle": "^1.11.0",
     "bare-mime": "^1.0.0",
     "bare-module-lexer": "^1.6.0",
     "bare-module-resolve": "^1.7.0"