bare-module-traverse 2.5.3 → 2.5.5

package/README.md

@@ -128,6 +128,9 @@ next.value = {
     url: URL,
     source: 'string' | Buffer,
     type: constants.SCRIPT,
+    // The type the module has on its own, ignoring import attributes, or 0 if
+    // it has no type of its own.
+    naturalType: constants.SCRIPT,
     imports: {
       // See https://github.com/holepunchto/bare-module#imports
     },

package/index.d.ts

@@ -11,7 +11,15 @@ import { type Import, type Export } from 'bare-module-lexer'
 interface Dependency {
   url: URL
   source: string | Buffer
+  /** The type the module is loaded as. See `constants` for possible values. */
   type: number
+  /**
+   * The type the module has on its own, ignoring import attributes, or `0` if
+   * it has no type of its own. This differs from `type` only when an import
+   * attribute asked for a different type, so a loader can use it to tell
+   * whether an attribute changed the type.
+   */
+  naturalType: number
   imports: ImportsMap
   lexer: {
     imports: Import[]
@@ -35,15 +43,16 @@ type AliasableExtension =
 
 interface TraverseOptions extends ResolveOptions {
   /**
-   * The type assumed for a module that names none of its own, such as an
-   * ambiguous extension or a `data:` URL that no import reaches. See
+   * The type to assume for a module that has no type of its own, such as one
+   * with an ambiguous extension or a `data:` URL that no import reaches. See
    * `constants` for possible values.
    */
   defaultType?: number
   /**
-   * The type of the import that names the entry. A `data:` URL of JavaScript
-   * takes its type from this: `REQUIRE` names a script and `IMPORT` a module,
-   * while `IMPORT | DYNAMIC` names either and so must carry a `type` attribute.
+   * The type of the import that led to the entry. A JavaScript `data:` URL
+   * takes its type from this: `REQUIRE` means a script and `IMPORT` a module,
+   * while `IMPORT | DYNAMIC` could mean either and so needs a `type`
+   * attribute.
    */
   importType?: number
   artifacts?: boolean

package/index.js

@@ -192,9 +192,19 @@ exports.alias = function alias(url, opts = {}) {
 }
 
 exports.module = function* (url, source, attributes, artifacts, visited, opts = {}) {
-  const { resolutions = null, asset = false, probed } = opts
+  const { resolutions = null, asset = false, probed, types } = opts
 
-  if (visited.has(url.href)) return false
+  attributes = attributes || {}
+
+  if (visited.has(url.href)) {
+    // An asset is only read for its bytes, so it doesn't care what type the
+    // module is imported as elsewhere.
+    if (asset === false && types !== undefined) {
+      assertTypeAgrees(url, attributes, types.get(url.href), opts)
+    }
+
+    return false
+  }
 
   visited.add(url.href)
 
@@ -202,8 +212,7 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
 
   if (opts.packages === undefined) opts = { ...opts, packages: new Map() }
   if (opts.prefixes === undefined) opts = { ...opts, prefixes: new Map() }
-
-  attributes = attributes || {}
+  if (opts.types === undefined) opts = { ...opts, types: new Map() }
 
   const artifact = asset === true || moduleType(url, attributes, null, opts) === constants.ADDON
 
@@ -264,6 +273,9 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
   }
 
   const type = moduleType(url, attributes, info, opts)
+  const naturalType = naturalModuleType(url, attributes, info, type, opts)
+
+  if (asset === false) opts.types.set(url.href, { type, asserted: attributes.type, info })
 
   const lexer = { imports: [], exports: [] }
 
@@ -283,6 +295,7 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
       url: exports.alias(url, opts),
       source,
       type,
+      naturalType,
       imports: compressImportsMap(imports),
       lexer
     }
@@ -310,6 +323,7 @@ exports.package = function* (url, source, artifacts, visited, opts = {}) {
         url,
         source,
         type: constants.JSON,
+        naturalType: constants.JSON,
         imports: {},
         lexer: { imports: [], exports: [] }
       }
@@ -392,7 +406,10 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
   const lexer = { imports: [], exports: [] }
 
   if (type === constants.SCRIPT || type === constants.MODULE) {
-    lexer.exports = lex(source).exports
+    const lexed = lex(source)
+
+    lexer.imports = lexed.imports
+    lexer.exports = lexed.exports
   }
 
   yield {
@@ -400,6 +417,7 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
       url: exports.alias(url, opts),
       source,
       type,
+      naturalType: type,
       imports: compressImportsMap(imports),
       lexer
     }
@@ -810,6 +828,17 @@ function* postresolve(url) {
   return (yield { resolution: url }) || url
 }
 
+// The type a module has on its own, ignoring import attributes. A JavaScript
+// data: URL has no type of its own, so this returns 0; its type depends on how
+// it is imported.
+function naturalModuleType(url, attributes, info, type, opts) {
+  if (attributes.type === undefined) return type
+
+  if (url.protocol === 'data:') return 0
+
+  return moduleType(url, {}, info, opts)
+}
+
 function moduleType(url, attributes, info, opts = {}) {
   const { defaultType = constants.SCRIPT, aliases = null } = opts
 
@@ -857,6 +886,46 @@ function moduleType(url, attributes, info, opts = {}) {
   return defaultType
 }
 
+// A URL has a single type within a graph, and the first import to reach it
+// decides what that is. Later imports have to agree, so an attribute on one
+// import cannot quietly change the type another import sees.
+function assertTypeAgrees(url, attributes, recorded, opts) {
+  if (recorded === undefined) return
+  if (attributes.type === recorded.asserted) return
+
+  const expected =
+    typeof attributes.type === 'string'
+      ? typeForAttribute(attributes.type)
+      : moduleType(url, {}, recorded.info, opts)
+
+  if (expected === recorded.type) return
+
+  throw errors.TYPE_INCOMPATIBLE(
+    `Module '${url.href}' is already of type '${attributeForType(recorded.type)}' in the graph`
+  )
+}
+
+function attributeForType(type) {
+  switch (type) {
+    case constants.SCRIPT:
+      return 'script'
+    case constants.MODULE:
+      return 'module'
+    case constants.JSON:
+      return 'json'
+    case constants.BUNDLE:
+      return 'bundle'
+    case constants.ADDON:
+      return 'addon'
+    case constants.BINARY:
+      return 'binary'
+    case constants.TEXT:
+      return 'text'
+  }
+
+  return 'unknown'
+}
+
 function typeForAttribute(type) {
   switch (type) {
     case 'script':
@@ -918,11 +987,11 @@ function dataURLModuleType(url, attributes, opts = {}) {
   return type
 }
 
-// A data URL carries no extension and 'text/javascript' spans both module
-// systems, so the type follows how the module was named: `require()` names a
-// script and `import` a module. A dynamic `import()` names either and so must
-// say which, as must a caller naming a data URL with no import to read, who
-// answers with `defaultType`.
+// A data URL has no extension, and 'text/javascript' covers both module
+// systems, so the type follows how the module was imported: `require()` means a
+// script and `import` a module. A dynamic `import()` could mean either, so it
+// has to say which. When there is no import to read at all, `defaultType`
+// decides.
 function javaScriptDataURLModuleType(url, opts) {
   const { defaultType = constants.SCRIPT, importType = 0 } = opts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-module-traverse",
-  "version": "2.5.3",
+  "version": "2.5.5",
   "description": "Low-level module graph traversal for Bare",
   "exports": {
     ".": {