bare-module-traverse 2.5.2 → 2.5.4

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[]
@@ -34,7 +42,19 @@ type AliasableExtension =
   | '.txt'
 
 interface TraverseOptions extends ResolveOptions {
+  /**
+   * 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 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
   aliases?: Record<string, AliasableExtension>
   /**

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: [] }
 
@@ -271,7 +283,7 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     if (type === constants.SCRIPT || type === constants.MODULE) {
       yield* exports.imports(url, source, imports, artifacts, lexer, visited, {
         ...opts,
-        referrerType: type
+        importType: 0
       })
     } else if (type === constants.ADDON && artifacts !== null) {
       yield* exports.addons(url, artifacts, visited, opts)
@@ -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: [] }
       }
@@ -363,7 +377,7 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
               children: exports.module(url, null, {}, artifacts, visited, {
                 ...opts,
                 asset: true,
-                referrerType: type
+                importType: 0
               }),
               deferred: true
             }
@@ -376,7 +390,7 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
           yield {
             children: exports.module(url, null, {}, artifacts, visited, {
               ...opts,
-              referrerType: type
+              importType: 0
             }),
             deferred: false
           }
@@ -400,6 +414,7 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
       url: exports.alias(url, opts),
       source,
       type,
+      naturalType: type,
       imports: compressImportsMap(imports),
       lexer
     }
@@ -611,7 +626,10 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
           }
 
           yield {
-            children: exports.module(resolution, source, attributes, artifacts, visited, opts),
+            children: exports.module(resolution, source, attributes, artifacts, visited, {
+              ...opts,
+              importType: entry.type
+            }),
             deferred: false
           }
 
@@ -807,6 +825,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
 
@@ -854,6 +883,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':
@@ -876,22 +945,22 @@ function typeForAttribute(type) {
 }
 
 function dataURLModuleType(url, attributes, opts = {}) {
-  const { defaultType = constants.SCRIPT, referrerType } = opts
-
   const { mime } = parseDataURL(url)
 
+  if (mime === null) {
+    throw errors.UNKNOWN_DATA_URL_MEDIA_TYPE(`Data URL '${url.href}' does not declare a media type`)
+  }
+
   const asserted = typeof attributes.type === 'string' ? typeForAttribute(attributes.type) : null
 
-  if (mime === null || mime.subtype === 'javascript') {
+  if (mime.subtype === 'javascript') {
     if (asserted === constants.SCRIPT || asserted === constants.MODULE) return asserted
 
     if (asserted !== null) {
       throw errors.TYPE_INCOMPATIBLE(`Module '${url.href}' is not of type '${attributes.type}'`)
     }
 
-    if (referrerType) return referrerType
-
-    return defaultType === constants.MODULE ? constants.MODULE : constants.SCRIPT
+    return javaScriptDataURLModuleType(url, opts)
   }
 
   let type
@@ -915,6 +984,27 @@ function dataURLModuleType(url, attributes, opts = {}) {
   return type
 }
 
+// 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
+
+  if (importType & lex.constants.REQUIRE) return constants.SCRIPT
+
+  if (importType & lex.constants.IMPORT) {
+    if ((importType & lex.constants.DYNAMIC) === 0) return constants.MODULE
+
+    throw errors.AMBIGUOUS_MODULE_TYPE(
+      `Module '${url.href}' must declare whether it is of type 'script' or 'module'`
+    )
+  }
+
+  return defaultType === constants.MODULE ? constants.MODULE : constants.SCRIPT
+}
+
 function parseDataURL(url) {
   const { pathname } = url
 

package/lib/errors.js

@@ -49,6 +49,14 @@ module.exports = class ModuleTraverseError extends Error {
     return new ModuleTraverseError(msg, ModuleTraverseError.TYPE_INCOMPATIBLE)
   }
 
+  static AMBIGUOUS_MODULE_TYPE(msg) {
+    return new ModuleTraverseError(msg, ModuleTraverseError.AMBIGUOUS_MODULE_TYPE)
+  }
+
+  static UNKNOWN_DATA_URL_MEDIA_TYPE(msg) {
+    return new ModuleTraverseError(msg, ModuleTraverseError.UNKNOWN_DATA_URL_MEDIA_TYPE)
+  }
+
   static UNKNOWN_DATA_URL_CHARSET(msg, charset) {
     const err = new ModuleTraverseError(msg, ModuleTraverseError.UNKNOWN_DATA_URL_CHARSET)
 

package/package.json

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