react-say - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1-master.45e468a

CHANGELOG.md

@@ -8,5 +8,12 @@ # Changelog
 ## [Unreleased]
+### Added
+- `exclusive` props: will cancel other utterances on speak
 
+### Changed
+- Lerna bootstrap will no longer hoist
+- Utterance queue are now controlled by `<Composer>` instead of `speechSynthesis` for better compatibility
+   - Chrome does not fire `start` and `end` events if `speak`/`cancel` are called too fast
+
 ## [1.0.0] - 2018-07-09
 ### Added
 - Initial release

lib/Composer.js

@@ -7,6 +7,154 @@ 'use strict';
 
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
 
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _regenerator = require('babel-runtime/regenerator');
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
+
+var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
+
+var speakUtterance = function () {
+  var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(_ref2, _ref3) {
+    var _this = this;
+
+    var speechSynthesis = _ref2.speechSynthesis;
+    var reject = _ref3.reject,
+        resolve = _ref3.resolve,
+        utterance = _ref3.utterance;
+    var startDeferred, errorDeferred, endDeferred, endEvent;
+    return _regenerator2.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            startDeferred = (0, _createDeferred2.default)();
+            errorDeferred = (0, _createDeferred2.default)();
+            endDeferred = (0, _createDeferred2.default)();
+
+
+            utterance.addEventListener('end', endDeferred.resolve);
+            utterance.addEventListener('error', errorDeferred.resolve);
+            utterance.addEventListener('start', startDeferred.resolve);
+
+            // if (speechSynthesis.speaking) {
+            //   console.warn(`ASSERTION: speechSynthesis.speaking should not be truthy before we call speak`);
+            // }
+
+            // Chrome quirks:
+            // 1. Speak an utterance
+            // 2. Cancel in the midway
+            // 3. Speak another utterance
+            // Expected: speaking is falsy, then turn to truthy, then receive "start" event, and audio played
+            // Actual: speaking is falsy, then turn to truthy (which is wrong), but receive no "start" event, and no audio played
+            // Workaround: retry 2 times with a second
+
+            // Safari quirks:
+            // - Audio doesn't play if the speech is started from a user event
+            // - If no audio is played, the "start" event won't fire
+
+            // console.debug(`STARTING: ${ utterance.text }`);
+
+            _context2.next = 9;
+            return (0, _retry2.default)((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
+              return _regenerator2.default.wrap(function _callee$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      speechSynthesis.speak(utterance);
+
+                      _context.prev = 1;
+                      _context.next = 4;
+                      return _promise2.default.race([startDeferred.promise, (0, _timeout2.default)(1000)]);
+
+                    case 4:
+                      _context.next = 10;
+                      break;
+
+                    case 6:
+                      _context.prev = 6;
+                      _context.t0 = _context['catch'](1);
+
+                      // This is required for Chrome quirks.
+                      // Chrome doesn't know it can't start speech, and it just wait there forever.
+                      // We need to cancel it out.
+                      speechSynthesis.cancel();
+
+                      throw _context.t0;
+
+                    case 10:
+                    case 'end':
+                      return _context.stop();
+                  }
+                }
+              }, _callee, _this, [[1, 6]]);
+            })), 2, 0);
+
+          case 9:
+            _context2.next = 11;
+            return _promise2.default.race([errorDeferred.promise, endDeferred.promise, (0, _spinWaitUntil2.default)(function () {
+              return !speechSynthesis.speaking;
+            }).then(function () {
+              return (0, _sleep2.default)(500);
+            }).then(function () {
+              return { type: 'end', artificial: true };
+            })]);
+
+          case 11:
+            endEvent = _context2.sent;
+            _context2.t0 = endEvent.type;
+            _context2.next = _context2.t0 === 'cancel' ? 15 : _context2.t0 === 'error' ? 17 : 18;
+            break;
+
+          case 15:
+            speechSynthesis.cancel();
+            throw new Error('cancelled');
+
+          case 17:
+            throw endEvent.error;
+
+          case 18:
+            return _context2.abrupt('return', resolve());
+
+          case 21:
+            _context2.prev = 21;
+            _context2.t1 = _context2['catch'](0);
+            return _context2.abrupt('return', reject(_context2.t1));
+
+          case 24:
+          case 'end':
+            return _context2.stop();
+        }
+      }
+    }, _callee2, this, [[0, 21]]);
+  }));
+
+  return function speakUtterance(_x, _x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
 var _memoizeOne = require('memoize-one');
@@ -28,85 +176,228 @@
 
+var _createDeferred = require('./createDeferred');
+
+var _createDeferred2 = _interopRequireDefault(_createDeferred);
+
+var _retry = require('./retry');
+
+var _retry2 = _interopRequireDefault(_retry);
+
+var _sleep = require('./sleep');
+
+var _sleep2 = _interopRequireDefault(_sleep);
+
+var _spinWaitUntil = require('./spinWaitUntil');
+
+var _spinWaitUntil2 = _interopRequireDefault(_spinWaitUntil);
+
+var _timeout = require('./timeout');
+
+var _timeout2 = _interopRequireDefault(_timeout);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function createUtterance(utteranceLike, ponyfill) {
+  var SpeechSynthesisUtterance = ponyfill.SpeechSynthesisUtterance;
+  var lang = utteranceLike.lang,
+      onBoundary = utteranceLike.onBoundary,
+      onEnd = utteranceLike.onEnd,
+      onError = utteranceLike.onError,
+      onStart = utteranceLike.onStart,
+      _utteranceLike$pitch = utteranceLike.pitch,
+      pitch = _utteranceLike$pitch === undefined ? 1 : _utteranceLike$pitch,
+      _utteranceLike$rate = utteranceLike.rate,
+      rate = _utteranceLike$rate === undefined ? 1 : _utteranceLike$rate,
+      text = utteranceLike.text,
+      voice = utteranceLike.voice,
+      _utteranceLike$volume = utteranceLike.volume,
+      volume = _utteranceLike$volume === undefined ? 1 : _utteranceLike$volume;
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+  var utterance = new SpeechSynthesisUtterance(text);
+  var targetVoice = void 0;
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+  if (typeof voice === 'function') {
+    targetVoice = voice.call(speechSynthesis, getSerializableVoices(speechSynthesis));
+  } else {
+    var _ref = voice || {},
+        voiceURI = _ref.voiceURI;
 
-function createContext(_ref) {
-  var speechSynthesis = _ref.speechSynthesis,
-      speechSynthesisUtterance = _ref.speechSynthesisUtterance;
+    targetVoice = voiceURI && [].find.call([].slice.call(getSerializableVoices(speechSynthesis)), function (v) {
+      return v.voiceURI === voiceURI;
+    });
+  }
 
-  return {
-    cancel: function cancel() {
-      return speechSynthesis.cancel();
-    },
-    speak: function speak(_ref2) {
-      var lang = _ref2.lang,
-          onBoundary = _ref2.onBoundary,
-          onEnd = _ref2.onEnd,
-          onError = _ref2.onError,
-          onStart = _ref2.onStart,
-          _ref2$pitch = _ref2.pitch,
-          pitch = _ref2$pitch === undefined ? 1 : _ref2$pitch,
-          _ref2$rate = _ref2.rate,
-          rate = _ref2$rate === undefined ? 1 : _ref2$rate,
-          text = _ref2.text,
-          voice = _ref2.voice,
-          _ref2$volume = _ref2.volume,
-          volume = _ref2$volume === undefined ? 1 : _ref2$volume;
+  // Edge will mute if "lang" is set to ""
+  utterance.lang = lang || '';
 
-      var utterance = new speechSynthesisUtterance(text);
-      var targetVoice = void 0;
+  if (utterance.pitch || utterance.pitch === 0) {
+    utterance.pitch = pitch;
+  }
 
-      if (typeof voice === 'function') {
-        targetVoice = voice.call(speechSynthesis, speechSynthesis.getVoices());
-      } else {
-        var _ref3 = voice || {},
-            voiceURI = _ref3.voiceURI;
+  if (utterance.rate || utterance.rate === 0) {
+    utterance.rate = rate;
+  }
 
-        targetVoice = voiceURI && [].find.call([].slice.call(speechSynthesis.getVoices()), function (v) {
-          return v.voiceURI === voiceURI;
-        });
+  // Cognitive Services will error when "voice" is set to "null"
+  // Edge will error when "voice" is set to "undefined"
+  if (targetVoice) {
+    utterance.voice = targetVoice;
+  }
+
+  if (utterance.volume || utterance.volume === 0) {
+    utterance.volume = volume;
+  }
+
+  if (utterance.addEventListener) {
+    utterance.addEventListener('boundary', onBoundary);
+    utterance.addEventListener('end', onEnd);
+    utterance.addEventListener('error', onError);
+    utterance.addEventListener('start', onStart);
+  }
+
+  return utterance;
+}
+
+var SpeechContext = function () {
+  function SpeechContext(ponyfill) {
+    (0, _classCallCheck3.default)(this, SpeechContext);
+
+    this.queueWithCurrent = [];
+
+    this.cancel = this.cancel.bind(this);
+    this.speak = this.speak.bind(this);
+
+    this.setPonyfill(ponyfill);
+  }
+
+  (0, _createClass3.default)(SpeechContext, [{
+    key: 'setPonyfill',
+    value: function setPonyfill(_ref6) {
+      var speechSynthesis = _ref6.speechSynthesis,
+          SpeechSynthesisUtterance = _ref6.SpeechSynthesisUtterance;
+
+      this.ponyfill = { speechSynthesis: speechSynthesis, SpeechSynthesisUtterance: SpeechSynthesisUtterance };
+    }
+  }, {
+    key: 'cancel',
+    value: function () {
+      var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3() {
+        var cancelAll;
+        return _regenerator2.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                // console.debug(`CANCELLING QUEUED ITEMS: ${ this.queueWithCurrent.length }`);
+
+                this.queueWithCurrent.forEach(function (entry) {
+                  return entry.cancelled = true;
+                });
+
+                cancelAll = _promise2.default.all(this.queueWithCurrent.map(function (_ref8) {
+                  var promise = _ref8.deferred.promise;
+                  return promise.catch(function (err) {
+                    return 0;
+                  });
+                }));
+
+
+                this.ponyfill.speechSynthesis.cancel();
+
+                _context3.prev = 3;
+                _context3.next = 6;
+                return cancelAll;
+
+              case 6:
+                _context3.next = 10;
+                break;
+
+              case 8:
+                _context3.prev = 8;
+                _context3.t0 = _context3['catch'](3);
+
+              case 10:
+              case 'end':
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this, [[3, 8]]);
+      }));
+
+      function cancel() {
+        return _ref7.apply(this, arguments);
       }
 
-      // Edge will mute if "lang" is set to ""
-      utterance.lang = lang || '';
+      return cancel;
+    }()
+  }, {
+    key: 'speak',
+    value: function speak(utteranceLike) {
+      var deferred = (0, _createDeferred2.default)();
 
-      if (utterance.pitch || utterance.pitch === 0) {
-        utterance.pitch = pitch;
+      // console.debug(`QUEUED: ${ utteranceLike.text }`);
+
+      if (utteranceLike.uniqueID && this.queueWithCurrent.find(function (_ref9) {
+        var uniqueID = _ref9.utteranceLike.uniqueID;
+        return utteranceLike.uniqueID === uniqueID;
+      })) {
+        // Do not queue duplicated speak with same unique ID
+        return;
       }
 
-      if (utterance.rate || utterance.rate === 0) {
-        utterance.rate = rate;
+      this.queueWithCurrent.push({
+        deferred: deferred,
+        utteranceLike: utteranceLike
+      });
+
+      if (this.queueWithCurrent.length === 1) {
+        this._next();
       }
 
-      // Cognitive Services will error when "voice" is set to "null"
-      // Edge will error when "voice" is set to "undefined"
-      if (targetVoice) {
-        utterance.voice = targetVoice;
+      return deferred.promise;
+    }
+  }, {
+    key: '_next',
+    value: function _next() {
+      var _this2 = this;
+
+      var entry = this.queueWithCurrent[0];
+
+      if (!entry) {
+        return;
       }
 
-      if (utterance.volume || utterance.volume === 0) {
-        utterance.volume = volume;
+      entry.deferred.promise.then(function () {
+        _this2.queueWithCurrent.shift();
+        _this2._next();
+      }, function () {
+        // TODO: If the error is due to Safari restriction on user touch
+        //       The next loop on the next audio will also fail because it was not queued with a user touch
+        _this2.queueWithCurrent.shift();
+        _this2._next();
+      });
+
+      if (entry.cancelled) {
+        // console.debug(`CANCELLED BEFORE PLAY: ${ entry.utteranceLike.text }`);
+
+        return entry.deferred.reject(new Error('cancelled'));
       }
 
-      utterance.onboundary = onBoundary;
-      utterance.onend = onEnd;
-      utterance.onerror = onError;
-      utterance.onstart = onStart;
+      var utterance = createUtterance(entry.utteranceLike, this.ponyfill);
 
-      speechSynthesis.speak(utterance);
+      speakUtterance(this.ponyfill, {
+        reject: entry.deferred.reject,
+        resolve: entry.deferred.resolve,
+        utterance: utterance
+      });
     }
-  };
-}
+  }]);
+  return SpeechContext;
+}();
 
-function getVoices(speechSynthesis) {
-  return speechSynthesis.getVoices().map(function (_ref4) {
-    var def = _ref4['default'],
-        lang = _ref4.lang,
-        localService = _ref4.localService,
-        name = _ref4.name,
-        voiceURI = _ref4.voiceURI;
+function getSerializableVoices(speechSynthesis) {
+  return speechSynthesis.getVoices().map(function (_ref10) {
+    var def = _ref10['default'],
+        lang = _ref10.lang,
+        localService = _ref10.localService,
+        name = _ref10.name,
+        voiceURI = _ref10.voiceURI;
     return {
@@ -123,25 +414,34 @@ 'default': def,
 var Composer = function (_React$Component) {
-  _inherits(Composer, _React$Component);
+  (0, _inherits3.default)(Composer, _React$Component);
 
   function Composer(props) {
-    _classCallCheck(this, Composer);
+    (0, _classCallCheck3.default)(this, Composer);
 
-    var _this = _possibleConstructorReturn(this, (Composer.__proto__ || Object.getPrototypeOf(Composer)).call(this, props));
+    var _this3 = (0, _possibleConstructorReturn3.default)(this, (Composer.__proto__ || (0, _getPrototypeOf2.default)(Composer)).call(this, props));
 
-    _this.handleVoicesChanged = _this.handleVoicesChanged.bind(_this);
+    _this3.handleVoicesChanged = _this3.handleVoicesChanged.bind(_this3);
 
-    props.speechSynthesis.onvoiceschanged = _this.handleVoicesChanged;
+    props.speechSynthesis.addEventListener && props.speechSynthesis.addEventListener('voiceschanged', _this3.handleVoicesChanged);
 
-    _this.mergeContext = (0, _memoizeOne2.default)(function (context, voices) {
-      return _extends({}, context, { voices: voices });
+    _this3.mergeContext = (0, _memoizeOne2.default)(function (_ref11, voices) {
+      var cancel = _ref11.cancel,
+          speak = _ref11.speak;
+      return {
+        cancel: cancel,
+        speak: speak,
+        voices: voices
+      };
     });
 
-    _this.state = {
-      context: createContext(props),
-      voices: getVoices(props.speechSynthesis)
+    _this3.state = {
+      context: new SpeechContext({
+        speechSynthesis: props.speechSynthesis,
+        SpeechSynthesisUtterance: props.speechSynthesisUtterance
+      }),
+      voices: getSerializableVoices(props.speechSynthesis)
     };
-    return _this;
+    return _this3;
   }
 
-  _createClass(Composer, [{
+  (0, _createClass3.default)(Composer, [{
     key: 'componentWillReceiveProps',
@@ -156,16 +456,17 @@ value: function componentWillReceiveProps(nextProps) {
       if (changed) {
-        this.props.speechSynthesis.onvoiceschanged = null;
-        this.state.context.cancel();
+        if (props.speechSynthesis) {
+          props.speechSynthesis.removeEventListener && props.speechSynthesis.removeEventListener('voiceschanged', this.handleVoicesChanged);
+        }
 
-        nextProps.speechSynthesis.onvoiceschanged = this.handleVoicesChanged;
+        this.state.context.setPonyfill({
+          speechSynthesis: nextProps.speechSynthesis,
+          SpeechSynthesisUtterance: nextProps.speechSynthesisUtterance
+        });
 
-        this.setState(function (_ref5) {
-          var context = _ref5.context;
+        if (nextProps.speechSynthesis) {
+          nextProps.speechSynthesis.addEventListener && nextProps.speechSynthesis.addEventListener('voiceschanged', this.handleVoicesChanged);
+        }
 
-          context.cancel();
-
-          return {
-            context: createContext(nextProps),
-            voices: getVoices(nextProps.speechSynthesis)
-          };
+        this.setState(function () {
+          return { voices: getSerializableVoices(nextProps.speechSynthesis) };
         });
@@ -175,10 +476,16 @@ }
   }, {
+    key: 'componentWillUnmount',
+    value: function componentWillUnmount() {
+      var speechSynthesis = this.props.speechSynthesis;
+
+
+      speechSynthesis && speechSynthesis.removeEventListener && speechSynthesis.removeEventListener('voiceschanged', this.handleVoicesChanged);
+    }
+  }, {
     key: 'handleVoicesChanged',
-    value: function handleVoicesChanged(_ref6) {
-      var target = _ref6.target;
+    value: function handleVoicesChanged(_ref12) {
+      var target = _ref12.target;
 
-      var voices = getVoices(target);
-
       this.setState(function () {
-        return { voices: voices };
+        return { voices: getSerializableVoices(target) };
       });
@@ -189,2 +496,4 @@ }
     value: function render() {
+      var _this4 = this;
+
       var props = this.props,
@@ -196,15 +505,20 @@ state = this.state;
       return _react2.default.createElement(
-        _Context2.default.Provider,
-        { value: this.mergeContext(state.context, state.voices) },
-        typeof children === 'function' ? _react2.default.createElement(
-          _Context2.default.Consumer,
-          null,
-          function (context) {
-            return children(context);
-          }
-        ) : children
+        _Context2.default.Consumer,
+        null,
+        function (context) {
+          return context ? typeof children === 'function' ? children(context) : children : _react2.default.createElement(
+            _Context2.default.Provider,
+            { value: _this4.mergeContext(state.context, state.voices) },
+            typeof children === 'function' ? _react2.default.createElement(
+              _Context2.default.Consumer,
+              null,
+              function (context) {
+                return children(context);
+              }
+            ) : children
+          );
+        }
       );
     }
   }]);
-
   return Composer;
@@ -222,15 +536,5 @@ }(_react2.default.Component);
 Composer.propTypes = {
-  lang: _propTypes2.default.string,
-  onBoundary: _propTypes2.default.func,
-  onEnd: _propTypes2.default.func,
-  onError: _propTypes2.default.func,
-  onStart: _propTypes2.default.func,
-  pitch: _propTypes2.default.number,
-  rate: _propTypes2.default.number,
-  text: _propTypes2.default.string,
-  voice: _propTypes2.default.oneOfType([_propTypes2.default.any, _propTypes2.default.func]),
-  volume: _propTypes2.default.number,
   speechSynthesis: _propTypes2.default.any,
   speechSynthesisUtterance: _propTypes2.default.any
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Composer.js"],"names":["createContext","speechSynthesis","speechSynthesisUtterance","cancel","speak","lang","onBoundary","onEnd","onError","onStart","pitch","rate","text","voice","volume","utterance","targetVoice","call","getVoices","voiceURI","find","slice","v","onboundary","onend","onerror","onstart","map","def","localService","name","Composer","props","handleVoicesChanged","bind","onvoiceschanged","mergeContext","context","voices","state","nextProps","changed","some","setState","target","children","React","Component","defaultProps","window","webkitSpeechSynthesis","SpeechSynthesisUtterance","webkitSpeechSynthesisUtterance","propTypes","PropTypes","string","func","number","oneOfType","any"],"mappings":"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","file":"Composer.js","sourcesContent":["import memoize from 'memoize-one';\nimport PropTypes from 'prop-types';\nimport React from 'react';\n\nimport Context from './Context';\n\nfunction createContext({\n  speechSynthesis,\n  speechSynthesisUtterance\n}) {\n  return {\n    cancel: () => speechSynthesis.cancel(),\n    speak: ({\n      lang,\n      onBoundary,\n      onEnd,\n      onError,\n      onStart,\n      pitch = 1,\n      rate = 1,\n      text,\n      voice,\n      volume = 1\n    }) => {\n      const utterance = new speechSynthesisUtterance(text);\n      let targetVoice;\n\n      if (typeof voice === 'function') {\n        targetVoice = voice.call(speechSynthesis, speechSynthesis.getVoices());\n      } else {\n        const { voiceURI } = voice || {};\n\n        targetVoice = voiceURI && [].find.call([].slice.call(speechSynthesis.getVoices()), v => v.voiceURI === voiceURI);\n      }\n\n      // Edge will mute if \"lang\" is set to \"\"\n      utterance.lang = lang || '';\n\n      if (utterance.pitch || utterance.pitch === 0) {\n        utterance.pitch = pitch;\n      }\n\n      if (utterance.rate || utterance.rate === 0) {\n        utterance.rate = rate;\n      }\n\n      // Cognitive Services will error when \"voice\" is set to \"null\"\n      // Edge will error when \"voice\" is set to \"undefined\"\n      if (targetVoice) {\n        utterance.voice = targetVoice;\n      }\n\n      if (utterance.volume || utterance.volume === 0) {\n        utterance.volume = volume;\n      }\n\n      utterance.onboundary = onBoundary;\n      utterance.onend = onEnd;\n      utterance.onerror = onError;\n      utterance.onstart = onStart;\n\n      speechSynthesis.speak(utterance);\n    }\n  };\n}\n\nfunction getVoices(speechSynthesis) {\n  return speechSynthesis.getVoices().map(({\n    'default': def,\n    lang,\n    localService,\n    name,\n    voiceURI\n  }) => ({\n    'default': def,\n    lang,\n    localService,\n    name,\n    voiceURI\n  }));\n}\n\nexport default class Composer extends React.Component {\n  constructor(props) {\n    super(props);\n\n    this.handleVoicesChanged = this.handleVoicesChanged.bind(this);\n\n    props.speechSynthesis.onvoiceschanged = this.handleVoicesChanged;\n\n    this.mergeContext = memoize((context, voices) => ({ ...context, voices }));\n\n    this.state = {\n      context: createContext(props),\n      voices: getVoices(props.speechSynthesis)\n    };\n  }\n\n  componentWillReceiveProps(nextProps) {\n    const { props } = this;\n    const changed = [\n      'speechSynthesis',\n      'speechSynthesisUtterance'\n    ].some(name => nextProps[name] !== props[name]);\n\n    if (changed) {\n      this.props.speechSynthesis.onvoiceschanged = null;\n      this.state.context.cancel();\n\n      nextProps.speechSynthesis.onvoiceschanged = this.handleVoicesChanged;\n\n      this.setState(({ context }) => {\n        context.cancel();\n\n        return {\n          context: createContext(nextProps),\n          voices: getVoices(nextProps.speechSynthesis)\n        };\n      });\n    }\n  }\n\n  handleVoicesChanged({ target }) {\n    const voices = getVoices(target);\n\n    this.setState(() => ({ voices }));\n  }\n\n  render() {\n    const { props, state } = this;\n    const { children } = props;\n\n    return (\n      <Context.Provider value={ this.mergeContext(state.context, state.voices) }>\n        {\n          typeof children === 'function' ?\n            <Context.Consumer>\n              { context => children(context) }\n            </Context.Consumer>\n          :\n            children\n        }\n      </Context.Provider>\n    );\n  }\n}\n\nComposer.defaultProps = {\n  speechSynthesis: window.speechSynthesis || window.webkitSpeechSynthesis,\n  speechSynthesisUtterance: window.SpeechSynthesisUtterance || window.webkitSpeechSynthesisUtterance\n};\n\nComposer.propTypes = {\n  lang: PropTypes.string,\n  onBoundary: PropTypes.func,\n  onEnd: PropTypes.func,\n  onError: PropTypes.func,\n  onStart: PropTypes.func,\n  pitch: PropTypes.number,\n  rate: PropTypes.number,\n  text: PropTypes.string,\n  voice: PropTypes.oneOfType([PropTypes.any, PropTypes.func]),\n  volume: PropTypes.number,\n  speechSynthesis: PropTypes.any,\n  speechSynthesisUtterance: PropTypes.any\n};\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Composer.js"],"names":["speechSynthesis","reject","resolve","utterance","startDeferred","errorDeferred","endDeferred","addEventListener","speak","race","promise","cancel","speaking","then","type","artificial","endEvent","Error","error","speakUtterance","createUtterance","utteranceLike","ponyfill","SpeechSynthesisUtterance","lang","onBoundary","onEnd","onError","onStart","pitch","rate","text","voice","volume","targetVoice","call","getSerializableVoices","voiceURI","find","slice","v","SpeechContext","queueWithCurrent","bind","setPonyfill","forEach","entry","cancelled","cancelAll","all","map","deferred","catch","uniqueID","push","length","_next","shift","getVoices","def","localService","name","Composer","props","handleVoicesChanged","mergeContext","voices","state","context","speechSynthesisUtterance","nextProps","changed","some","removeEventListener","setState","target","children","React","Component","defaultProps","window","webkitSpeechSynthesis","webkitSpeechSynthesisUtterance","propTypes","PropTypes","any"],"mappings":"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","file":"Composer.js","sourcesContent":["import memoize from 'memoize-one';\nimport PropTypes from 'prop-types';\nimport React from 'react';\n\nimport Context from './Context';\nimport createDeferred from './createDeferred';\nimport retry from './retry';\nimport sleep from './sleep';\nimport spinWaitUntil from './spinWaitUntil';\nimport timeout from './timeout';\n\nfunction createUtterance(utteranceLike, ponyfill) {\n  const { SpeechSynthesisUtterance } = ponyfill;\n  const {\n    lang,\n    onBoundary,\n    onEnd,\n    onError,\n    onStart,\n    pitch = 1,\n    rate = 1,\n    text,\n    voice,\n    volume = 1\n  } = utteranceLike;\n  const utterance = new SpeechSynthesisUtterance(text);\n  let targetVoice;\n\n  if (typeof voice === 'function') {\n    targetVoice = voice.call(speechSynthesis, getSerializableVoices(speechSynthesis));\n  } else {\n    const { voiceURI } = voice || {};\n\n    targetVoice = voiceURI && [].find.call([].slice.call(getSerializableVoices(speechSynthesis)), v => v.voiceURI === voiceURI);\n  }\n\n  // Edge will mute if \"lang\" is set to \"\"\n  utterance.lang = lang || '';\n\n  if (utterance.pitch || utterance.pitch === 0) {\n    utterance.pitch = pitch;\n  }\n\n  if (utterance.rate || utterance.rate === 0) {\n    utterance.rate = rate;\n  }\n\n  // Cognitive Services will error when \"voice\" is set to \"null\"\n  // Edge will error when \"voice\" is set to \"undefined\"\n  if (targetVoice) {\n    utterance.voice = targetVoice;\n  }\n\n  if (utterance.volume || utterance.volume === 0) {\n    utterance.volume = volume;\n  }\n\n  if (utterance.addEventListener) {\n    utterance.addEventListener('boundary', onBoundary);\n    utterance.addEventListener('end', onEnd);\n    utterance.addEventListener('error', onError);\n    utterance.addEventListener('start', onStart);\n  }\n\n  return utterance;\n}\n\nasync function speakUtterance({ speechSynthesis }, { reject, resolve, utterance }) {\n  try {\n    const startDeferred = createDeferred();\n    const errorDeferred = createDeferred();\n    const endDeferred = createDeferred();\n\n    utterance.addEventListener('end', endDeferred.resolve);\n    utterance.addEventListener('error', errorDeferred.resolve);\n    utterance.addEventListener('start', startDeferred.resolve);\n\n    // if (speechSynthesis.speaking) {\n    //   console.warn(`ASSERTION: speechSynthesis.speaking should not be truthy before we call speak`);\n    // }\n\n    // Chrome quirks:\n    // 1. Speak an utterance\n    // 2. Cancel in the midway\n    // 3. Speak another utterance\n    // Expected: speaking is falsy, then turn to truthy, then receive \"start\" event, and audio played\n    // Actual: speaking is falsy, then turn to truthy (which is wrong), but receive no \"start\" event, and no audio played\n    // Workaround: retry 2 times with a second\n\n    // Safari quirks:\n    // - Audio doesn't play if the speech is started from a user event\n    // - If no audio is played, the \"start\" event won't fire\n\n    // console.debug(`STARTING: ${ utterance.text }`);\n\n    await retry(async () => {\n      speechSynthesis.speak(utterance);\n\n      try {\n        await Promise.race([\n          startDeferred.promise,\n          timeout(1000)\n        ]);\n      } catch (error) {\n        // This is required for Chrome quirks.\n        // Chrome doesn't know it can't start speech, and it just wait there forever.\n        // We need to cancel it out.\n        speechSynthesis.cancel();\n\n        throw error;\n      }\n    }, 2, 0);\n\n    // console.debug(`STARTED: ${ utterance.text }`);\n\n    const endEvent = await Promise.race([\n      errorDeferred.promise,\n      endDeferred.promise,\n      spinWaitUntil(() => !speechSynthesis.speaking).then(() => sleep(500)).then(() => ({ type: 'end', artificial: true }))\n    ]);\n\n    // if (speechSynthesis.speaking) {\n    //   console.warn(`ASSERTION: speechSynthesis.speaking should not be truthy after speak is stopped`);\n    // }\n\n    // console.debug(`ENDED: ${ next.utteranceLike.text }`);\n\n    switch (endEvent.type) {\n      case 'cancel':\n        speechSynthesis.cancel();\n        throw new Error('cancelled');\n\n      case 'error':\n        throw endEvent.error;\n    }\n\n    return resolve();\n  } catch (error) {\n    return reject(error);\n  }\n}\n\nclass SpeechContext {\n  constructor(ponyfill) {\n    this.queueWithCurrent = [];\n\n    this.cancel = this.cancel.bind(this);\n    this.speak = this.speak.bind(this);\n\n    this.setPonyfill(ponyfill);\n  }\n\n  setPonyfill({ speechSynthesis, SpeechSynthesisUtterance }) {\n    this.ponyfill = { speechSynthesis, SpeechSynthesisUtterance };\n  }\n\n  async cancel() {\n    // console.debug(`CANCELLING QUEUED ITEMS: ${ this.queueWithCurrent.length }`);\n\n    this.queueWithCurrent.forEach(entry => entry.cancelled = true);\n\n    const cancelAll = Promise.all(this.queueWithCurrent.map(({ deferred: { promise } }) => promise.catch(err => 0)));\n\n    this.ponyfill.speechSynthesis.cancel();\n\n    try {\n      await cancelAll;\n    } catch (err) {}\n\n    // console.debug(`ALL CANCELLED OR FINISHED`);\n  }\n\n  speak(utteranceLike) {\n    const deferred = createDeferred();\n\n    // console.debug(`QUEUED: ${ utteranceLike.text }`);\n\n    if (\n      utteranceLike.uniqueID\n      && this.queueWithCurrent.find(({ utteranceLike: { uniqueID } }) => utteranceLike.uniqueID === uniqueID)\n    ) {\n      // Do not queue duplicated speak with same unique ID\n      return;\n    }\n\n    this.queueWithCurrent.push({\n      deferred,\n      utteranceLike\n    });\n\n    if (this.queueWithCurrent.length === 1) {\n      this._next();\n    }\n\n    return deferred.promise;\n  }\n\n  _next() {\n    const entry = this.queueWithCurrent[0];\n\n    if (!entry) { return; }\n\n    entry.deferred.promise.then(() => {\n      this.queueWithCurrent.shift();\n      this._next();\n    }, () => {\n      // TODO: If the error is due to Safari restriction on user touch\n      //       The next loop on the next audio will also fail because it was not queued with a user touch\n      this.queueWithCurrent.shift();\n      this._next();\n    });\n\n    if (entry.cancelled) {\n      // console.debug(`CANCELLED BEFORE PLAY: ${ entry.utteranceLike.text }`);\n\n      return entry.deferred.reject(new Error('cancelled'));\n    }\n\n    const utterance = createUtterance(entry.utteranceLike, this.ponyfill);\n\n    speakUtterance(this.ponyfill, {\n      reject: entry.deferred.reject,\n      resolve: entry.deferred.resolve,\n      utterance\n    });\n  }\n}\n\nfunction getSerializableVoices(speechSynthesis) {\n  return speechSynthesis.getVoices().map(({\n    'default': def,\n    lang,\n    localService,\n    name,\n    voiceURI\n  }) => ({\n    'default': def,\n    lang,\n    localService,\n    name,\n    voiceURI\n  }));\n}\n\nexport default class Composer extends React.Component {\n  constructor(props) {\n    super(props);\n\n    this.handleVoicesChanged = this.handleVoicesChanged.bind(this);\n\n    props.speechSynthesis.addEventListener && props.speechSynthesis.addEventListener('voiceschanged', this.handleVoicesChanged);\n\n    this.mergeContext = memoize(({ cancel, speak }, voices) => ({\n      cancel,\n      speak,\n      voices\n    }));\n\n    this.state = {\n      context: new SpeechContext({\n        speechSynthesis: props.speechSynthesis,\n        SpeechSynthesisUtterance: props.speechSynthesisUtterance\n      }),\n      voices: getSerializableVoices(props.speechSynthesis)\n    };\n  }\n\n  componentWillReceiveProps(nextProps) {\n    const { props } = this;\n    const changed = [\n      'speechSynthesis',\n      'speechSynthesisUtterance'\n    ].some(name => nextProps[name] !== props[name]);\n\n    if (changed) {\n      if (props.speechSynthesis) {\n        props.speechSynthesis.removeEventListener && props.speechSynthesis.removeEventListener('voiceschanged', this.handleVoicesChanged);\n      }\n\n      this.state.context.setPonyfill({\n        speechSynthesis: nextProps.speechSynthesis,\n        SpeechSynthesisUtterance: nextProps.speechSynthesisUtterance\n      });\n\n      if (nextProps.speechSynthesis) {\n        nextProps.speechSynthesis.addEventListener && nextProps.speechSynthesis.addEventListener('voiceschanged', this.handleVoicesChanged);\n      }\n\n      this.setState(() => ({ voices: getSerializableVoices(nextProps.speechSynthesis) }));\n    }\n  }\n\n  componentWillUnmount() {\n    const { speechSynthesis } = this.props;\n\n    speechSynthesis && speechSynthesis.removeEventListener && speechSynthesis.removeEventListener('voiceschanged', this.handleVoicesChanged);\n  }\n\n  handleVoicesChanged({ target }) {\n    this.setState(() => ({ voices: getSerializableVoices(target) }));\n  }\n\n  render() {\n    const { props, state } = this;\n    const { children } = props;\n\n    return (\n      <Context.Consumer>\n        { context => context ?\n            typeof children === 'function' ? children(context) : children\n          :\n            <Context.Provider value={ this.mergeContext(state.context, state.voices) }>\n              {\n                typeof children === 'function' ?\n                  <Context.Consumer>\n                    { context => children(context) }\n                  </Context.Consumer>\n                :\n                  children\n              }\n            </Context.Provider>\n        }\n      </Context.Consumer>\n    );\n  }\n}\n\nComposer.defaultProps = {\n  speechSynthesis: window.speechSynthesis || window.webkitSpeechSynthesis,\n  speechSynthesisUtterance: window.SpeechSynthesisUtterance || window.webkitSpeechSynthesisUtterance\n};\n\nComposer.propTypes = {\n  speechSynthesis: PropTypes.any,\n  speechSynthesisUtterance: PropTypes.any\n};\n"]}

lib/Context.js

@@ -13,11 +13,5 @@ 'use strict';
 
-var Context = _react2.default.createContext({
-  cancel: function cancel() {},
-  getVoices: function getVoices() {
-    return [];
-  },
-  speak: function speak() {}
-});
+var Context = _react2.default.createContext();
 
 exports.default = Context;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9Db250ZXh0LmpzIl0sIm5hbWVzIjpbIkNvbnRleHQiLCJSZWFjdCIsImNyZWF0ZUNvbnRleHQiLCJjYW5jZWwiLCJnZXRWb2ljZXMiLCJzcGVhayJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUE7Ozs7OztBQUVBLElBQU1BLFVBQVVDLGdCQUFNQyxhQUFOLENBQW9CO0FBQ2xDQyxVQUFRLGtCQUFNLENBQUUsQ0FEa0I7QUFFbENDLGFBQVc7QUFBQSxXQUFNLEVBQU47QUFBQSxHQUZ1QjtBQUdsQ0MsU0FBTyxpQkFBTSxDQUFFO0FBSG1CLENBQXBCLENBQWhCOztrQkFNZUwsTyIsImZpbGUiOiJDb250ZXh0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcblxuY29uc3QgQ29udGV4dCA9IFJlYWN0LmNyZWF0ZUNvbnRleHQoe1xuICBjYW5jZWw6ICgpID0+IHt9LFxuICBnZXRWb2ljZXM6ICgpID0+IFtdLFxuICBzcGVhazogKCkgPT4ge31cbn0pO1xuXG5leHBvcnQgZGVmYXVsdCBDb250ZXh0XG4iXX0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9Db250ZXh0LmpzIl0sIm5hbWVzIjpbIkNvbnRleHQiLCJSZWFjdCIsImNyZWF0ZUNvbnRleHQiXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBOzs7Ozs7QUFFQSxJQUFNQSxVQUFVQyxnQkFBTUMsYUFBTixFQUFoQjs7a0JBRWVGLE8iLCJmaWxlIjoiQ29udGV4dC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5cbmNvbnN0IENvbnRleHQgPSBSZWFjdC5jcmVhdGVDb250ZXh0KCk7XG5cbmV4cG9ydCBkZWZhdWx0IENvbnRleHRcbiJdfQ==

lib/Say.js

@@ -35,2 +35,3 @@ 'use strict';
       {
+        exclusive: props.exclusive,
         lang: props.lang,
@@ -58,2 +59,3 @@ onBoundary: props.onBoundary,
 Say.propTypes = {
+  exclusive: _propTypes2.default.bool,
   lang: _propTypes2.default.string,
@@ -74,2 +76,2 @@ onBoundary: _propTypes2.default.func,
 exports.default = Say;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

lib/SayButton.js

@@ -24,3 +24,6 @@ 'use strict';
     _Context2.default.Consumer,
-    null,
+    {
+      speechSynthesis: props.speechSynthesis,
+      speechSynthesisUtterance: props.speechSynthesisUtterance
+    },
     function (context) {
@@ -30,2 +33,4 @@ return _react2.default.createElement(
         { onClick: function onClick(event) {
+            props.exclusive && context.cancel();
+
             context.speak({
@@ -43,2 +48,3 @@ lang: props.lang,
             });
+
             props.onClick && props.onClick(event);
@@ -53,2 +59,3 @@ } },
 SayButton.propTypes = {
+  exclusive: _propTypes2.default.bool,
   lang: _propTypes2.default.string,
@@ -67,2 +74,2 @@ onBoundary: _propTypes2.default.func,
 exports.default = SayButton;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

lib/SayPrimitive.js

@@ -7,4 +7,22 @@ 'use strict';
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
 
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
 var _propTypes = require('prop-types');
@@ -24,15 +42,9 @@
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
 var Say = function (_React$Component) {
-  _inherits(Say, _React$Component);
+  (0, _inherits3.default)(Say, _React$Component);
 
   function Say(props) {
-    _classCallCheck(this, Say);
+    (0, _classCallCheck3.default)(this, Say);
 
-    var _this = _possibleConstructorReturn(this, (Say.__proto__ || Object.getPrototypeOf(Say)).call(this, props));
+    var _this = (0, _possibleConstructorReturn3.default)(this, (Say.__proto__ || (0, _getPrototypeOf2.default)(Say)).call(this, props));
 
@@ -43,8 +55,11 @@ _this.handleBoundary = _this.handleBoundary.bind(_this);
     _this.handleStart = _this.handleStart.bind(_this);
+
+    _this.state = { uniqueID: Date.now() + Math.random() };
     return _this;
   }
 
-  _createClass(Say, [{
+  (0, _createClass3.default)(Say, [{
     key: 'componentWillUnmount',
     value: function componentWillUnmount() {
+      // TODO: Should dequeue self on unmount
       this.unmounted = true;
@@ -83,2 +98,3 @@ }
       var _props = this.props,
+          exclusive = _props.exclusive,
           lang = _props.lang,
@@ -90,2 +106,3 @@ pitch = _props.pitch,
           volume = _props.volume;
+      var uniqueID = this.state.uniqueID;
 
@@ -97,3 +114,5 @@
         function (context) {
-          return context.speak({
+          exclusive && context.cancel();
+
+          context.speak({
             lang: lang,
@@ -107,5 +126,8 @@ onBoundary: _this2.handleBoundary,
             text: text,
+            uniqueID: uniqueID,
             voice: voice,
             volume: volume
           });
+
+          return false;
         }
@@ -115,3 +137,2 @@ );
   }]);
-
   return Say;
@@ -124,2 +145,3 @@ }(_react2.default.Component);
 Say.propTypes = {
+  exclusive: _propTypes2.default.bool,
   lang: _propTypes2.default.string,
@@ -136,2 +158,2 @@ pitch: _propTypes2.default.number,
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package.json

 {
   "name": "react-say",
-  "version": "1.0.0",
+  "version": "1.0.1-master.45e468a",
   "description": "A React component that synthesis text into speech using Web Speech API",
-  "keywords": [],
+  "keywords": [
+    "react",
+    "speak",
+    "speech synthesis",
+    "speechsynthesis",
+    "text to speech",
+    "tts",
+    "utterance",
+    "web speech",
+    "webspeech"
+  ],
   "main": "lib/index.js",
@@ -11,3 +21,3 @@ "files": [
   "scripts": {
-    "bootstrap": "lerna bootstrap --hoist",
+    "bootstrap": "lerna bootstrap",
     "build": "lerna run build",
@@ -26,22 +36,14 @@ "test": "lerna run test"
   "homepage": "https://github.com/compulim/react-say#readme",
-  "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-core": "^6.26.3",
-    "babel-env": "^2.4.1",
-    "babel-plugin-transform-object-rest-spread": "^6.26.0",
-    "babel-preset-stage-3": "^6.24.1",
-    "jest": "^22.4.4",
-    "lerna": "^2.11.0",
-    "react": "^16.4.1",
-    "react-dom": "^16.4.1",
-    "react-scripts": "1.1.4",
-    "rimraf": "^2.6.2"
-  },
   "dependencies": {
     "classnames": "^2.2.6",
-    "glamor": "^2.20.40"
+    "event-as-promise": "^1.0.3",
+    "glamor": "^2.20.40",
+    "memoize-one": "^4.0.0"
   },
   "peerDependencies": {
     "react": "^16.4.1"
+  },
+  "devDependencies": {
+    "lerna": "^2.11.0"
   }
 }

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

82213

increased by65.34%

Dev dependency count

1

decreased by-90.91%

Number of package files

15

increased by50%

Lines of code

815

increased by91.31%

Worsened metrics

Dependency count

5

increased by66.67%

Number of low quality alerts

1

increased byInfinity%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedevent-as-promise@^1.0.3

• + Addedmemoize-one@^4.0.0

• + Addedevent-as-promise@1.1.0(transitive)

• + Addedmemoize-one@4.1.0(transitive)