@sentry/bundler-plugin-core 0.1.0 → 0.2.0

package/dist/esm/index.js

@@ -818,7 +818,7 @@ function normalizeUserOptions(userOptions) {
     // Optional options
     setCommits: userOptions.setCommits,
     deploy: userOptions.deploy,
-    entries: normalizeEntries(userOptions.entries),
+    releaseInjectionTargets: normalizeReleaseInjectionTargets(userOptions.releaseInjectionTargets),
     dist: userOptions.dist,
     errorHandler: userOptions.errorHandler,
     configFile: userOptions.configFile
@@ -831,16 +831,17 @@ function normalizeUserOptions(userOptions) {
   return options;
 }
 /**
- * Converts the user-facing `entries` option to the internal `entries` option
+ * Converts the user-facing `releaseInjectionTargets` option to the internal
+ * `releaseInjectionTargets` option
  */
 
-function normalizeEntries(userEntries) {
-  if (userEntries === undefined) {
+function normalizeReleaseInjectionTargets(userReleaseInjectionTargets) {
+  if (userReleaseInjectionTargets === undefined) {
     return undefined;
-  } else if (typeof userEntries === "function") {
-    return userEntries;
+  } else if (typeof userReleaseInjectionTargets === "function") {
+    return userReleaseInjectionTargets;
   } else {
-    return arrayify(userEntries);
+    return arrayify(userReleaseInjectionTargets);
   }
 }
 /**
@@ -945,7 +946,7 @@ function makeSentryClient(dsn, telemetryEnabled) {
     enabled: telemetryEnabled,
     tracesSampleRate: telemetryEnabled ? 1.0 : 0.0,
     sampleRate: telemetryEnabled ? 1.0 : 0.0,
-    release: "0.1.0",
+    release: "0.2.0",
     integrations: [new Integrations.Http({
       tracing: true
     })],
@@ -1475,6 +1476,7 @@ function getDryRunCLI(cli, logger) {
 // This hack is taken straight from https://rollupjs.org/guide/en/#resolveid.
 // This probably doesn't work for all bundlers but for rollup it does.
 var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
+var ALLOWED_TRANSFORMATION_FILE_ENDINGS = [".js", ".ts", ".jsx", ".tsx", ".cjs", ".mjs"];
 /**
  * The sentry bundler plugin concerns itself with two things:
  * - Release injection
@@ -1482,45 +1484,11 @@ var RELEASE_INJECTOR_ID = "\0sentry-release-injector";
  *
  * Release injection:
  *
- * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` variable into the entrypoint of all bundles.
- * On a technical level this is done by appending an import (`import "sentry-release-injector;"`) to all entrypoint files
- * of the user code (see `transformInclude` and `transform` hooks). This import is then resolved by the sentry plugin
- * to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
- *
- * The resulting output approximately looks like this:
- *
- * ```text
- *                               entrypoint1.js (user file)
- *  ┌─────────────────────────┐  ┌─────────────────────────────────────────────────┐
- *  │                         │  │  import { myFunction } from "./my-library.js";  │
- *  │  sentry-bundler-plugin  │  │                                                 │
- *  │                         │  │  const myResult = myFunction();                 │
- *  └---------│---------------   │  export { myResult };                           │
- *            │                  │                                                 │
- *            │      injects     │  // injected by sentry plugin                   │
- *            ├───────────────────► import "sentry-release-injector"; ─────────────────────┐
- *            │                  └─────────────────────────────────────────────────┘       │
- *            │                                                                            │
- *            │                                                                            │
- *            │                  entrypoint2.js (user file)                                │
- *            │                  ┌─────────────────────────────────────────────────┐       │
- *            │                  │  export function myFunction() {                 │       │
- *            │                  │    return "Hello world!";                       │       │
- *            │                  │  }                                              │       │
- *            │                  │                                                 │       │
- *            │      injects     │  // injected by sentry plugin                   │       │
- *            └───────────────────► import "sentry-release-injector"; ─────────────────────┤
- *                               └─────────────────────────────────────────────────┘       │
- *                                                                                         │
- *                                                                                         │
- *                               sentry-release-injector                                   │
- *                               ┌──────────────────────────────────┐                      │
- *                               │                                  │    is resolved       │
- *                               │  global.SENTRY_RELEASE = { ... } │    by plugin         │
- *                               │  // + a little more logic        │<─────────────────────┘
- *                               │                                  │    (only once)
- *                               └──────────────────────────────────┘
- * ```
+ * Per default the sentry bundler plugin will inject a global `SENTRY_RELEASE` into each JavaScript/TypeScript module
+ * that is part of the bundle. On a technical level this is done by appending an import (`import "sentry-release-injector;"`)
+ * to all entrypoint files of the user code (see `transformInclude` and `transform` hooks). This import is then resolved
+ * by the sentry plugin to a virtual module that sets the global variable (see `resolveId` and `load` hooks).
+ * If a user wants to inject the release into a particular set of modules they can use the `releaseInjectionTargets` option.
  *
  * Source maps upload:
  *
@@ -1569,12 +1537,7 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
   });
   sentryHub.setUser({
     id: internalOptions.org
-  }); // This is `nonEntrypointSet` instead of `entrypointSet` because this set is filled in the `resolveId` hook and there
-  // we don't have guaranteed access to *absolute* paths of files if they're entrypoints. For non-entrypoints we're
-  // guaranteed to have absolute paths - we're then using the paths in later hooks to make decisions about whether a
-  // file is an entrypoint or a non-entrypoint.
-
-  var nonEntrypointSet = new Set();
+  });
   var transaction;
   var releaseInjectionSpan;
   return {
@@ -1651,10 +1614,6 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
         level: "info"
       });
 
-      if (!isEntry) {
-        nonEntrypointSet.add(id);
-      }
-
       if (id === RELEASE_INJECTOR_ID) {
         return RELEASE_INJECTOR_ID;
       } else {
@@ -1695,7 +1654,7 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
 
     /**
      * This hook determines whether we want to transform a module. In the sentry bundler plugin we want to transform every entrypoint
-     * unless configured otherwise with the `entries` option.
+     * unless configured otherwise with the `releaseInjectionTargets` option.
      *
      * @param id Always the absolute (fully resolved) path to the module.
      * @returns `true` or `false` depending on whether we want to transform the module. For the sentry bundler plugin we only
@@ -1705,30 +1664,37 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
       sentryHub.addBreadcrumb({
         category: "transformInclude",
         level: "info"
-      });
+      }); // We don't want to transform our injected code.
 
-      if (internalOptions.entries) {
-        // If there's an `entries` option transform (ie. inject the release varible) when the file path matches the option.
-        if (typeof internalOptions.entries === "function") {
-          return internalOptions.entries(id);
+      if (id === RELEASE_INJECTOR_ID) {
+        return false;
+      }
+
+      if (internalOptions.releaseInjectionTargets) {
+        // If there's an `releaseInjectionTargets` option transform (ie. inject the release varible) when the file path matches the option.
+        if (typeof internalOptions.releaseInjectionTargets === "function") {
+          return internalOptions.releaseInjectionTargets(id);
         }
 
-        return internalOptions.entries.some(function (entry) {
+        return internalOptions.releaseInjectionTargets.some(function (entry) {
           if (entry instanceof RegExp) {
             return entry.test(id);
           } else {
             return id === entry;
           }
         });
-      } // We want to transform (release injection) every module except for "sentry-release-injector".
-
-
-      return id !== RELEASE_INJECTOR_ID && !nonEntrypointSet.has(id);
+      } else {
+        var pathIsOrdinary = !id.includes("?") && !id.includes("#");
+        var pathHasAllowedFileEnding = ALLOWED_TRANSFORMATION_FILE_ENDINGS.some(function (allowedFileEnding) {
+          return id.endsWith(allowedFileEnding);
+        });
+        return pathIsOrdinary && pathHasAllowedFileEnding;
+      }
     },
 
     /**
      * This hook is responsible for injecting the "sentry release injector" imoprt statement into each entrypoint unless
-     * configured otherwise with the `entries` option (logic for that is in the `transformInclude` hook).
+     * configured otherwise with the `releaseInjectionTargets` option (logic for that is in the `transformInclude` hook).
      *
      * @param code Code of the file to transform.
      * @param id Always the absolute (fully resolved) path to the module.
@@ -1740,11 +1706,10 @@ var unplugin = createUnplugin(function (options, unpluginMetaContext) {
         level: "info"
       }); // The MagicString library allows us to generate sourcemaps for the changes we make to the user code.
 
-      var ms = new MagicString(code); // Very stupid author's note: For some absurd reason, when we add a JSDoc to this hook, the TS language server starts complaining about `ms` and adding a type annotation helped so that's why it's here. (┛ಠ_ಠ)┛彡┻━┻
-      // appending instead of prepending has less probability of mucking with user'sadly
-      // source maps and import statements get to the top anyways
+      var ms = new MagicString(code); // Appending instead of prepending has less probability of mucking with user's source maps.
+      // Luckily import statements get hoisted to the top anyways.
 
-      ms.append("import \"".concat(RELEASE_INJECTOR_ID, "\";"));
+      ms.append(";\nimport \"".concat(RELEASE_INJECTOR_ID, "\";"));
 
       if (unpluginMetaContext.framework === "esbuild") {
         // esbuild + unplugin is buggy at the moment when we return an object with a `map` (sourcemap) property.