bare-module-traverse 2.5.2 → 2.5.3

package/index.d.ts

@@ -34,7 +34,18 @@ type AliasableExtension =
   | '.txt'
 
 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
+   * `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.
+   */
+  importType?: number
   artifacts?: boolean
   aliases?: Record<string, AliasableExtension>
   /**

package/index.js

@@ -271,7 +271,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)
@@ -363,7 +363,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 +376,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
           }
@@ -611,7 +611,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
           }
 
@@ -876,22 +879,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 +918,27 @@ 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`.
+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.3",
   "description": "Low-level module graph traversal for Bare",
   "exports": {
     ".": {