@storybook/telemetry 6.5.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Kadira Inc. <hello@kadira.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# Storybook Telemetry
+
+Storybook collects completely anonymous telemetry data about general usage. Participation in this program is optional and it’s easy to opt-out.
+
+For more information visit: [storybook.js.org/telemetry](https://storybook.js.org/telemetry)

package/dist/cjs/anonymous-id.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAnonymousProjectId = void 0;
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.string.trim.js");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _child_process = require("child_process");
+
+var _coreCommon = require("@storybook/core-common");
+
+var _oneWayHash = require("./one-way-hash");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var anonymousProjectId;
+
+var getAnonymousProjectId = function getAnonymousProjectId() {
+  if (anonymousProjectId) {
+    return anonymousProjectId;
+  }
+
+  var unhashedProjectId;
+
+  try {
+    var projectRoot = (0, _coreCommon.getProjectRoot)();
+
+    var projectRootPath = _path.default.relative(projectRoot, process.cwd());
+
+    var originBuffer = (0, _child_process.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 = (0, _oneWayHash.oneWayHash)(unhashedProjectId);
+  return anonymousProjectId;
+};
+
+exports.getAnonymousProjectId = getAnonymousProjectId;

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

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.monorepoConfigs = exports.getMonorepoType = void 0;
+
+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.array.join.js");
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _coreCommon = require("@storybook/core-common");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var monorepoConfigs = {
+  Nx: 'nx.json',
+  Turborepo: 'turbo.json',
+  Lerna: 'lerna.json',
+  Rush: 'rush.json',
+  Lage: 'lage.config.json'
+};
+exports.monorepoConfigs = monorepoConfigs;
+
+var getMonorepoType = function getMonorepoType() {
+  var projectRootPath = (0, _coreCommon.getProjectRoot)();
+  if (!projectRootPath) return undefined;
+  var monorepoType = Object.keys(monorepoConfigs).find(function (monorepo) {
+    var configFile = _path.default.join(projectRootPath, monorepoConfigs[monorepo]);
+
+    return _fsExtra.default.existsSync(configFile);
+  });
+
+  if (monorepoType) {
+    return monorepoType;
+  }
+
+  var packageJson = _fsExtra.default.readJsonSync(_path.default.join(projectRootPath, 'package.json'));
+
+  if (packageJson !== null && packageJson !== void 0 && packageJson.workspaces) {
+    return 'Workspaces';
+  }
+
+  return undefined;
+};
+
+exports.getMonorepoType = getMonorepoType;

package/dist/cjs/index.js

@@ -0,0 +1,130 @@
+"use strict";
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.object.keys.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  telemetry: true
+};
+exports.telemetry = void 0;
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.promise.js");
+
+require("regenerator-runtime/runtime.js");
+
+var _clientLogger = require("@storybook/client-logger");
+
+var _storybookMetadata = require("./storybook-metadata");
+
+Object.keys(_storybookMetadata).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _storybookMetadata[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _storybookMetadata[key];
+    }
+  });
+});
+
+var _telemetry = require("./telemetry");
+
+var _notify = require("./notify");
+
+var _sanitize = require("./sanitize");
+
+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 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 (0, _notify.notify)();
+
+          case 4:
+            telemetryData = {
+              eventType: eventType,
+              payload: payload
+            };
+            _context.prev = 5;
+            _context.next = 8;
+            return (0, _storybookMetadata.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 = (0, _sanitize.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;
+            }
+
+            _clientLogger.logger.info('\n[telemetry]');
+
+            _clientLogger.logger.info(JSON.stringify(telemetryData, null, 2));
+
+            _context.next = 25;
+            break;
+
+          case 23:
+            _context.next = 25;
+            return (0, _telemetry.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);
+  };
+}();
+
+exports.telemetry = telemetry;

package/dist/cjs/notify.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.notify = void 0;
+
+require("regenerator-runtime/runtime.js");
+
+require("core-js/modules/es.string.bold.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.promise.js");
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _coreCommon = require("@storybook/core-common");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TELEMETRY_KEY_NOTIFY_DATE = 'telemetry-notification-date';
+var logger = console;
+
+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 _coreCommon.cache.get(TELEMETRY_KEY_NOTIFY_DATE, null);
+
+          case 2:
+            telemetryNotifyDate = _context.sent;
+
+            if (!telemetryNotifyDate) {
+              _context.next = 5;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 5:
+            _coreCommon.cache.set(TELEMETRY_KEY_NOTIFY_DATE, Date.now());
+
+            logger.log();
+            logger.log("".concat(_chalk.default.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.default.cyan('https://storybook.js.org/telemetry'));
+            logger.log();
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function notify() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.notify = notify;

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.oneWayHash = void 0;
+
+var _crypto = require("crypto");
+
+var oneWayHash = function oneWayHash(payload) {
+  var hash = (0, _crypto.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');
+};
+
+exports.oneWayHash = oneWayHash;

package/dist/cjs/package-versions.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getActualPackageVersions = exports.getActualPackageVersion = void 0;
+
+require("regenerator-runtime/runtime.js");
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.string.iterator.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.array.map.js");
+
+require("core-js/modules/es.array.join.js");
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 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);
+  };
+}();
+
+exports.getActualPackageVersions = getActualPackageVersions;
+
+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.default.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);
+  };
+}();
+
+exports.getActualPackageVersion = getActualPackageVersion;

package/dist/cjs/sanitize.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanPaths = cleanPaths;
+exports.sanitizeError = sanitizeError;
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.replace.js");
+
+require("core-js/modules/es.string.split.js");
+
+require("core-js/modules/es.array.join.js");
+
+require("core-js/modules/es.regexp.constructor.js");
+
+require("core-js/modules/es.regexp.to-string.js");
+
+require("core-js/modules/es.object.get-own-property-names.js");
+
+var _path = require("path");
+
+/* eslint-disable no-param-reassign */
+// Removes all user paths
+function regexpEscape(str) {
+  return str.replace(/[-[/{}()*+?.\\^$|]/g, "\\$&");
+}
+
+function cleanPaths(str) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _path.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
+
+
+function sanitizeError(error) {
+  var pathSeparator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _path.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);
+}