@storybook/telemetry 6.5.0-beta.2

package/dist/esm/notify.js

@@ -0,0 +1,54 @@
+import "regenerator-runtime/runtime.js";
+import "core-js/modules/es.string.bold.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.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 chalk from 'chalk';
+import { cache } from '@storybook/core-common';
+var TELEMETRY_KEY_NOTIFY_DATE = 'telemetry-notification-date';
+var logger = console;
+export var notify = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+    var telemetryNotifyDate;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return cache.get(TELEMETRY_KEY_NOTIFY_DATE, null);
+
+          case 2:
+            telemetryNotifyDate = _context.sent;
+
+            if (!telemetryNotifyDate) {
+              _context.next = 5;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 5:
+            cache.set(TELEMETRY_KEY_NOTIFY_DATE, Date.now());
+            logger.log();
+            logger.log("".concat(chalk.magenta.bold('attention'), " => Storybook now collects completely anonymous telemetry regarding usage."));
+            logger.log("This information is used to shape Storybook's roadmap and prioritize features.");
+            logger.log("You can learn more, including how to opt-out if you'd not like to participate in this anonymous program, by visiting the following URL:");
+            logger.log(chalk.cyan('https://storybook.js.org/telemetry'));
+            logger.log();
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function notify() {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/esm/one-way-hash.js

@@ -0,0 +1,11 @@
+import { createHash } from 'crypto';
+export var oneWayHash = function oneWayHash(payload) {
+  var hash = createHash('sha256'); // Always prepend the payload value with salt. This ensures the hash is truly
+  // one-way.
+
+  hash.update('storybook-telemetry-salt'); // Update is an append operation, not a replacement. The salt from the prior
+  // update is still present!
+
+  hash.update(payload);
+  return hash.digest('hex');
+};

package/dist/esm/package-versions.js

@@ -0,0 +1,72 @@
+import "regenerator-runtime/runtime.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.join.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 path from 'path';
+export var getActualPackageVersions = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(packages) {
+    var packageNames;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            packageNames = Object.keys(packages);
+            return _context.abrupt("return", Promise.all(packageNames.map(getActualPackageVersion)));
+
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getActualPackageVersions(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var getActualPackageVersion = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(packageName) {
+    var packageJson;
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            // eslint-disable-next-line import/no-dynamic-require,global-require
+            packageJson = require(path.join(packageName, 'package.json'));
+            return _context2.abrupt("return", {
+              name: packageName,
+              version: packageJson.version
+            });
+
+          case 5:
+            _context2.prev = 5;
+            _context2.t0 = _context2["catch"](0);
+            return _context2.abrupt("return", {
+              name: packageName,
+              version: null
+            });
+
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[0, 5]]);
+  }));
+
+  return function getActualPackageVersion(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/dist/esm/sanitize.js

@@ -0,0 +1,42 @@
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.string.split.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.regexp.constructor.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.object.get-own-property-names.js";
+
+/* eslint-disable no-param-reassign */
+import { sep } from 'path';
+
+// Removes all user paths
+function regexpEscape(str) {
+  return str.replace(/[-[/{}()*+?.\\^$|]/g, "\\$&");
+}
+
+export function cleanPaths(str) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : sep;
+  if (!str) return str;
+  var stack = process.cwd().split(separator);
+
+  while (stack.length > 1) {
+    var currentPath = stack.join(separator);
+    var currentRegex = new RegExp(regexpEscape(currentPath), "g");
+    str = str.replace(currentRegex, "$SNIP");
+    var currentPath2 = stack.join(separator + separator);
+    var currentRegex2 = new RegExp(regexpEscape(currentPath2), "g");
+    str = str.replace(currentRegex2, "$SNIP");
+    stack.pop();
+  }
+
+  return str;
+} // Takes an Error and returns a sanitized JSON String
+
+export function sanitizeError(error) {
+  var pathSeparator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : sep;
+  // Hack because Node
+  error = JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error))); // Removes all user paths
+
+  var errorString = cleanPaths(JSON.stringify(error), pathSeparator);
+  return JSON.parse(errorString);
+}

package/dist/esm/storybook-metadata.js

@@ -0,0 +1,304 @@
+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; }
+
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.object.assign.js";
+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.function.name.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.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 readPkgUp from 'read-pkg-up';
+import { detect, getNpmVersion } from 'detect-package-manager';
+import { loadMainConfig, getStorybookInfo, getStorybookConfiguration, getProjectRoot } from '@storybook/core-common';
+import { getActualPackageVersion, getActualPackageVersions } from './package-versions';
+import { getMonorepoType } from './get-monorepo-type';
+var cachedMetadata;
+export 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.sync({
+              cwd: process.cwd()
+            }).packageJson;
+            configDir = (_ref2 = _configDir || getStorybookConfiguration(packageJson.scripts.storybook, '-c', '--config-dir')) !== null && _ref2 !== void 0 ? _ref2 : '.storybook';
+            mainConfig = 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);
+  };
+}();
+export 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
+
+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
+
+
+export 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 getActualPackageVersion(metaFramework);
+
+          case 7:
+            _yield$getActualPacka = _context2.sent;
+            version = _yield$getActualPacka.version;
+            metadata.metaFramework = {
+              name: metaFrameworks[metaFramework],
+              packageName: metaFramework,
+              version: version
+            };
+
+          case 10:
+            monorepoType = getMonorepoType();
+
+            if (monorepoType) {
+              metadata.monorepo = monorepoType;
+            }
+
+            _context2.prev = 12;
+            _context2.next = 15;
+            return detect({
+              cwd: getProjectRoot()
+            });
+
+          case 15:
+            packageManagerType = _context2.sent;
+            _context2.next = 18;
+            return 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 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 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 = 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);
+  };
+}();

package/dist/esm/telemetry.js

@@ -0,0 +1,127 @@
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.symbol.js";
+var _excluded = ["payload", "metadata"];
+import "regenerator-runtime/runtime.js";
+
+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; }
+
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.filter.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 originalFetch from 'isomorphic-unfetch';
+import retry from 'fetch-retry';
+import { nanoid } from 'nanoid';
+import { getAnonymousProjectId } from './anonymous-id';
+var URL = 'https://storybook.js.org/event-log';
+var fetch = retry(originalFetch);
+var tasks = []; // getStorybookMetadata -> packagejson + Main.js
+// event specific data: sessionId, ip, etc..
+// send telemetry
+
+var sessionId = nanoid();
+export 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: getAnonymousProjectId(),
+              inCI: process.env.CI === 'true'
+            };
+            eventId = 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/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/modern/anonymous-id.js

@@ -0,0 +1,27 @@
+import path from 'path';
+import { execSync } from 'child_process';
+import { getProjectRoot } from '@storybook/core-common';
+import { oneWayHash } from './one-way-hash';
+let anonymousProjectId;
+export const getAnonymousProjectId = () => {
+  if (anonymousProjectId) {
+    return anonymousProjectId;
+  }
+
+  let unhashedProjectId;
+
+  try {
+    const projectRoot = getProjectRoot();
+    const projectRootPath = path.relative(projectRoot, process.cwd());
+    const 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 = `${String(originBuffer).trim()}${projectRootPath}`; // eslint-disable-next-line no-empty
+  } catch (_) {}
+
+  anonymousProjectId = oneWayHash(unhashedProjectId);
+  return anonymousProjectId;
+};

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

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