@storybook/telemetry 6.5.0-beta.2

package/dist/cjs/storybook-metadata.js

@@ -0,0 +1,346 @@
+"use strict";
+
+require("core-js/modules/es.array.slice.js");
+
+require("core-js/modules/es.array.from.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+require("core-js/modules/es.symbol.iterator.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.metaFrameworks = exports.getStorybookMetadata = exports.computeStorybookMetadata = void 0;
+
+require("core-js/modules/es.array.map.js");
+
+require("core-js/modules/es.object.assign.js");
+
+require("core-js/modules/es.array.find.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.function.name.js");
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.replace.js");
+
+require("core-js/modules/es.array.filter.js");
+
+require("core-js/modules/es.array.includes.js");
+
+require("core-js/modules/es.string.includes.js");
+
+require("core-js/modules/es.promise.js");
+
+require("regenerator-runtime/runtime.js");
+
+var _readPkgUp = _interopRequireDefault(require("read-pkg-up"));
+
+var _detectPackageManager = require("detect-package-manager");
+
+var _coreCommon = require("@storybook/core-common");
+
+var _packageVersions = require("./package-versions");
+
+var _getMonorepoType = require("./get-monorepo-type");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var cachedMetadata;
+
+var getStorybookMetadata = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(_configDir) {
+    var _ref2;
+
+    var packageJson, configDir, mainConfig;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!cachedMetadata) {
+              _context.next = 2;
+              break;
+            }
+
+            return _context.abrupt("return", cachedMetadata);
+
+          case 2:
+            packageJson = _readPkgUp.default.sync({
+              cwd: process.cwd()
+            }).packageJson;
+            configDir = (_ref2 = _configDir || (0, _coreCommon.getStorybookConfiguration)(packageJson.scripts.storybook, '-c', '--config-dir')) !== null && _ref2 !== void 0 ? _ref2 : '.storybook';
+            mainConfig = (0, _coreCommon.loadMainConfig)({
+              configDir: configDir
+            });
+            _context.next = 7;
+            return computeStorybookMetadata({
+              mainConfig: mainConfig,
+              packageJson: packageJson
+            });
+
+          case 7:
+            cachedMetadata = _context.sent;
+            return _context.abrupt("return", cachedMetadata);
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getStorybookMetadata(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.getStorybookMetadata = getStorybookMetadata;
+var metaFrameworks = {
+  next: 'Next',
+  'react-scripts': 'CRA',
+  gatsby: 'Gatsby',
+  '@nuxtjs/storybook': 'nuxt',
+  '@nrwl/storybook': 'nx',
+  '@vue/cli-service': 'vue-cli',
+  '@sveltejs/kit': 'svelte-kit'
+}; // @TODO: This should be removed in 7.0 as the framework.options field in main.js will replace this
+
+exports.metaFrameworks = metaFrameworks;
+
+var getFrameworkOptions = function getFrameworkOptions(mainConfig) {
+  var possibleOptions = ['angular', 'ember', 'html', 'preact', 'react', 'server', 'svelte', 'vue', 'vue3', 'webComponents'].map(function (opt) {
+    return "".concat(opt, "Options");
+  }); // eslint-disable-next-line no-restricted-syntax
+
+  var _iterator = _createForOfIteratorHelper(possibleOptions),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var opt = _step.value;
+
+      if (opt in mainConfig) {
+        return mainConfig[opt];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return undefined;
+}; // Analyze a combination of information from main.js and package.json
+// to provide telemetry over a Storybook project
+
+
+var computeStorybookMetadata = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(_ref3) {
+    var _mainConfig$core;
+
+    var packageJson, mainConfig, metadata, allDependencies, metaFramework, _yield$getActualPacka, version, monorepoType, packageManagerType, packageManagerVerson, _builder$options, builder, addons, addonVersions, addonNames, storybookPackages, storybookPackageVersions, language, hasStorybookEslint, storybookInfo;
+
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            packageJson = _ref3.packageJson, mainConfig = _ref3.mainConfig;
+            metadata = {
+              generatedAt: new Date().getTime(),
+              builder: {
+                name: 'webpack4'
+              },
+              hasCustomBabel: false,
+              hasCustomWebpack: false,
+              hasStaticDirs: false,
+              hasStorybookEslint: false,
+              refCount: 0
+            };
+            allDependencies = Object.assign({}, packageJson === null || packageJson === void 0 ? void 0 : packageJson.dependencies, packageJson === null || packageJson === void 0 ? void 0 : packageJson.devDependencies, packageJson === null || packageJson === void 0 ? void 0 : packageJson.peerDependencies);
+            metaFramework = Object.keys(allDependencies).find(function (dep) {
+              return !!metaFrameworks[dep];
+            });
+
+            if (!metaFramework) {
+              _context2.next = 10;
+              break;
+            }
+
+            _context2.next = 7;
+            return (0, _packageVersions.getActualPackageVersion)(metaFramework);
+
+          case 7:
+            _yield$getActualPacka = _context2.sent;
+            version = _yield$getActualPacka.version;
+            metadata.metaFramework = {
+              name: metaFrameworks[metaFramework],
+              packageName: metaFramework,
+              version: version
+            };
+
+          case 10:
+            monorepoType = (0, _getMonorepoType.getMonorepoType)();
+
+            if (monorepoType) {
+              metadata.monorepo = monorepoType;
+            }
+
+            _context2.prev = 12;
+            _context2.next = 15;
+            return (0, _detectPackageManager.detect)({
+              cwd: (0, _coreCommon.getProjectRoot)()
+            });
+
+          case 15:
+            packageManagerType = _context2.sent;
+            _context2.next = 18;
+            return (0, _detectPackageManager.getNpmVersion)(packageManagerType);
+
+          case 18:
+            packageManagerVerson = _context2.sent;
+            metadata.packageManager = {
+              type: packageManagerType,
+              version: packageManagerVerson
+            }; // Better be safe than sorry, some codebases/paths might end up breaking with something like "spawn pnpm ENOENT"
+            // so we just set the package manager if the detection is successful
+            // eslint-disable-next-line no-empty
+
+            _context2.next = 24;
+            break;
+
+          case 22:
+            _context2.prev = 22;
+            _context2.t0 = _context2["catch"](12);
+
+          case 24:
+            metadata.hasCustomBabel = !!mainConfig.babel;
+            metadata.hasCustomWebpack = !!mainConfig.webpackFinal;
+            metadata.hasStaticDirs = !!mainConfig.staticDirs;
+
+            if (mainConfig.typescript) {
+              metadata.typescriptOptions = mainConfig.typescript;
+            }
+
+            if ((_mainConfig$core = mainConfig.core) !== null && _mainConfig$core !== void 0 && _mainConfig$core.builder) {
+              builder = mainConfig.core.builder;
+              metadata.builder = {
+                name: typeof builder === 'string' ? builder : builder.name,
+                options: typeof builder === 'string' ? undefined : (_builder$options = builder === null || builder === void 0 ? void 0 : builder.options) !== null && _builder$options !== void 0 ? _builder$options : undefined
+              };
+            }
+
+            if (mainConfig.refs) {
+              metadata.refCount = Object.keys(mainConfig.refs).length;
+            }
+
+            if (mainConfig.features) {
+              metadata.features = mainConfig.features;
+            }
+
+            addons = {};
+
+            if (mainConfig.addons) {
+              mainConfig.addons.forEach(function (addon) {
+                var result;
+                var options;
+
+                if (typeof addon === 'string') {
+                  result = addon.replace('/register', '');
+                } else {
+                  options = addon.options;
+                  result = addon.name;
+                }
+
+                addons[result] = {
+                  options: options,
+                  version: undefined
+                };
+              });
+            }
+
+            _context2.next = 35;
+            return (0, _packageVersions.getActualPackageVersions)(addons);
+
+          case 35:
+            addonVersions = _context2.sent;
+            addonVersions.forEach(function (_ref5) {
+              var name = _ref5.name,
+                  version = _ref5.version;
+              addons[name].version = version;
+            });
+            addonNames = Object.keys(addons); // all Storybook deps minus the addons
+
+            storybookPackages = Object.keys(allDependencies).filter(function (dep) {
+              return dep.includes('storybook') && !addonNames.includes(dep);
+            }).reduce(function (acc, dep) {
+              return Object.assign({}, acc, _defineProperty({}, dep, {
+                version: undefined
+              }));
+            }, {});
+            _context2.next = 41;
+            return (0, _packageVersions.getActualPackageVersions)(storybookPackages);
+
+          case 41:
+            storybookPackageVersions = _context2.sent;
+            storybookPackageVersions.forEach(function (_ref6) {
+              var name = _ref6.name,
+                  version = _ref6.version;
+              storybookPackages[name].version = version;
+            });
+            language = allDependencies.typescript ? 'typescript' : 'javascript';
+            hasStorybookEslint = !!allDependencies['eslint-plugin-storybook'];
+            storybookInfo = (0, _coreCommon.getStorybookInfo)(packageJson);
+            return _context2.abrupt("return", Object.assign({}, metadata, {
+              storybookVersion: storybookInfo.version,
+              language: language,
+              storybookPackages: storybookPackages,
+              framework: {
+                name: storybookInfo.framework,
+                options: getFrameworkOptions(mainConfig)
+              },
+              addons: addons,
+              hasStorybookEslint: hasStorybookEslint
+            }));
+
+          case 47:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[12, 22]]);
+  }));
+
+  return function computeStorybookMetadata(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+exports.computeStorybookMetadata = computeStorybookMetadata;

package/dist/cjs/telemetry.js

@@ -0,0 +1,150 @@
+"use strict";
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.symbol.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sendTelemetry = sendTelemetry;
+
+require("regenerator-runtime/runtime.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.object.assign.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.array.filter.js");
+
+var _isomorphicUnfetch = _interopRequireDefault(require("isomorphic-unfetch"));
+
+var _fetchRetry = _interopRequireDefault(require("fetch-retry"));
+
+var _nanoid = require("nanoid");
+
+var _anonymousId = require("./anonymous-id");
+
+var _excluded = ["payload", "metadata"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var URL = 'https://storybook.js.org/event-log';
+var fetch = (0, _fetchRetry.default)(_isomorphicUnfetch.default);
+var tasks = []; // getStorybookMetadata -> packagejson + Main.js
+// event specific data: sessionId, ip, etc..
+// send telemetry
+
+var sessionId = (0, _nanoid.nanoid)();
+
+function sendTelemetry(_x) {
+  return _sendTelemetry.apply(this, arguments);
+}
+
+function _sendTelemetry() {
+  _sendTelemetry = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(data) {
+    var options,
+        payload,
+        metadata,
+        rest,
+        context,
+        eventId,
+        body,
+        request,
+        _args = arguments;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {
+              retryDelay: 1000,
+              immediate: false
+            };
+            // We use this id so we can de-dupe events that arrive at the index multiple times due to the
+            // use of retries. There are situations in which the request "5xx"s (or times-out), but
+            // the server actually gets the request and stores it anyway.
+            // flatten the data before we send it
+            payload = data.payload, metadata = data.metadata, rest = _objectWithoutProperties(data, _excluded);
+            context = {
+              anonymousId: (0, _anonymousId.getAnonymousProjectId)(),
+              inCI: process.env.CI === 'true'
+            };
+            eventId = (0, _nanoid.nanoid)();
+            body = Object.assign({}, rest, {
+              eventId: eventId,
+              sessionId: sessionId,
+              metadata: metadata,
+              payload: payload,
+              context: context
+            });
+            _context.prev = 5;
+            request = fetch(URL, {
+              method: 'POST',
+              body: JSON.stringify(body),
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              retries: 3,
+              retryOn: [503, 504],
+              retryDelay: function retryDelay(attempt) {
+                return Math.pow(2, attempt) * options.retryDelay;
+              }
+            });
+            tasks.push(request);
+
+            if (!options.immediate) {
+              _context.next = 13;
+              break;
+            }
+
+            _context.next = 11;
+            return Promise.all(tasks);
+
+          case 11:
+            _context.next = 15;
+            break;
+
+          case 13:
+            _context.next = 15;
+            return request;
+
+          case 15:
+            _context.next = 19;
+            break;
+
+          case 17:
+            _context.prev = 17;
+            _context.t0 = _context["catch"](5);
+
+          case 19:
+            _context.prev = 19;
+            tasks = tasks.filter(function (task) {
+              return task !== request;
+            });
+            return _context.finish(19);
+
+          case 22:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[5, 17, 19, 22]]);
+  }));
+  return _sendTelemetry.apply(this, arguments);
+}

package/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/esm/anonymous-id.js

@@ -0,0 +1,29 @@
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.string.trim.js";
+import path from 'path';
+import { execSync } from 'child_process';
+import { getProjectRoot } from '@storybook/core-common';
+import { oneWayHash } from './one-way-hash';
+var anonymousProjectId;
+export var getAnonymousProjectId = function getAnonymousProjectId() {
+  if (anonymousProjectId) {
+    return anonymousProjectId;
+  }
+
+  var unhashedProjectId;
+
+  try {
+    var projectRoot = getProjectRoot();
+    var projectRootPath = path.relative(projectRoot, process.cwd());
+    var originBuffer = execSync("git config --local --get remote.origin.url", {
+      timeout: 1000,
+      stdio: "pipe"
+    }); // we use a combination of remoteUrl and working directory
+    // to separate multiple storybooks from the same project (e.g. monorepo)
+
+    unhashedProjectId = "".concat(String(originBuffer).trim()).concat(projectRootPath); // eslint-disable-next-line no-empty
+  } catch (_) {}
+
+  anonymousProjectId = oneWayHash(unhashedProjectId);
+  return anonymousProjectId;
+};

package/dist/esm/get-monorepo-type.js

@@ -0,0 +1,34 @@
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.array.join.js";
+import fs from 'fs-extra';
+import path from 'path';
+import { getProjectRoot } from '@storybook/core-common';
+export var monorepoConfigs = {
+  Nx: 'nx.json',
+  Turborepo: 'turbo.json',
+  Lerna: 'lerna.json',
+  Rush: 'rush.json',
+  Lage: 'lage.config.json'
+};
+export var getMonorepoType = function getMonorepoType() {
+  var projectRootPath = getProjectRoot();
+  if (!projectRootPath) return undefined;
+  var monorepoType = Object.keys(monorepoConfigs).find(function (monorepo) {
+    var configFile = path.join(projectRootPath, monorepoConfigs[monorepo]);
+    return fs.existsSync(configFile);
+  });
+
+  if (monorepoType) {
+    return monorepoType;
+  }
+
+  var packageJson = fs.readJsonSync(path.join(projectRootPath, 'package.json'));
+
+  if (packageJson !== null && packageJson !== void 0 && packageJson.workspaces) {
+    return 'Workspaces';
+  }
+
+  return undefined;
+};

package/dist/esm/index.js

@@ -0,0 +1,94 @@
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "regenerator-runtime/runtime.js";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+import { logger } from '@storybook/client-logger';
+import { getStorybookMetadata } from './storybook-metadata';
+import { sendTelemetry } from './telemetry';
+import { notify } from './notify';
+import { sanitizeError } from './sanitize';
+export * from './storybook-metadata';
+export var telemetry = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(eventType) {
+    var payload,
+        options,
+        telemetryData,
+        error,
+        _process$env,
+        _args = arguments;
+
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            payload = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+            options = _args.length > 2 ? _args[2] : undefined;
+            _context.next = 4;
+            return notify();
+
+          case 4:
+            telemetryData = {
+              eventType: eventType,
+              payload: payload
+            };
+            _context.prev = 5;
+            _context.next = 8;
+            return getStorybookMetadata(options.configDir);
+
+          case 8:
+            telemetryData.metadata = _context.sent;
+            _context.next = 14;
+            break;
+
+          case 11:
+            _context.prev = 11;
+            _context.t0 = _context["catch"](5);
+            if (!telemetryData.payload.error) telemetryData.payload.error = _context.t0;
+
+          case 14:
+            _context.prev = 14;
+            error = telemetryData.payload.error;
+
+            if (error) {
+              // make sure to anonymise possible paths from error messages
+              telemetryData.payload.error = sanitizeError(error);
+            }
+
+            if (!(!telemetryData.payload.error || options.enableCrashReports)) {
+              _context.next = 25;
+              break;
+            }
+
+            if (!((_process$env = process.env) !== null && _process$env !== void 0 && _process$env.STORYBOOK_DEBUG_TELEMETRY)) {
+              _context.next = 23;
+              break;
+            }
+
+            logger.info('\n[telemetry]');
+            logger.info(JSON.stringify(telemetryData, null, 2));
+            _context.next = 25;
+            break;
+
+          case 23:
+            _context.next = 25;
+            return sendTelemetry(telemetryData, options);
+
+          case 25:
+            return _context.finish(14);
+
+          case 26:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[5, 11, 14, 26]]);
+  }));
+
+  return function telemetry(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();