web-speech-cognitive-services - npm Package Compare versions

Comparing version 0.0.1-master.e70a05d to 0.0.1-master.f80884e

lib/CognitiveServicesSpeechRecognition.js

@@ -7,2 +7,4 @@ '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 _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; }; }();
@@ -14,2 +16,6 @@
 
+var _eventAsPromise = require('event-as-promise');
+
+var _eventAsPromise2 = _interopRequireDefault(_eventAsPromise);
+
 var _memoizeOne = require('memoize-one');
@@ -23,2 +29,4 @@
 
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
 function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
@@ -77,6 +85,6 @@
       var name = 'Browser';
-      var osVersion = "0.0.1-master.e70a05d";
+      var osVersion = "0.0.1-master.f80884e";
       var manufacturer = 'web-speech-cognitive-services';
       var model = 'web-speech-cognitive-services';
-      var deviceVersion = "0.0.1-master.e70a05d";
+      var deviceVersion = "0.0.1-master.f80884e";
 
@@ -144,139 +152,202 @@ var config = new CognitiveSpeech.RecognizerConfig(new CognitiveSpeech.SpeechConfig(new CognitiveSpeech.Context(new CognitiveSpeech.OS(platform, name, osVersion), new CognitiveSpeech.Device(manufacturer, model, deviceVersion))), mode, lang, CognitiveSpeech.SpeechResultFormat.Detailed);
   _createClass(CognitiveServicesSpeechRecognition, [{
-    key: '_transitTo',
-    value: function _transitTo(nextReadyState) {
-      // console.log(`_transitTo: readyState = ${ this.readyState }, nextReadyState = ${ nextReadyState }`);
+    key: 'abort',
+    value: function abort() {
+      // TODO: Should redesign how to stop a recognition session
+      //       After abort is called, we should not saw it is a "success", "silent", or "no match"
+      var _ref3 = this.recognizer || {},
+          AudioSource = _ref3.AudioSource;
 
-      if (nextReadyState > this.readyState) {
-        var lifecycleEvents = [null, null, this.onstart, this.onaudiostart, this.onsoundstart, this.onspeechstart, this.onspeechend, this.onsoundend, this.onaudioend, this.onend];
+      AudioSource && AudioSource.TurnOff();
 
-        if (this.readyState === AUDIO_START && nextReadyState >= AUDIO_END) {
-          // If soundstart, speechstart, speechend, and soundend are not fired after audiostart,
-          // we can skip them and just fire audioend directly
-          this.readyState = SOUND_END;
-        }
+      this._aborted = true;
+    }
+  }, {
+    key: 'emit',
+    value: function emit(name, event) {
+      var listener = this['on' + name];
 
-        for (var transition = this.readyState + 1; transition <= nextReadyState; transition++) {
-          var eventListener = lifecycleEvents[transition];
-
-          // eventListener && console.log(`Firing "${ EVENT_TYPES[transition] }"`);
-          eventListener && eventListener({ type: EVENT_TYPES[transition] });
-        }
-
-        if (nextReadyState === END) {
-          this.readyState = IDLE;
-        } else {
-          this.readyState = nextReadyState;
-        }
-      }
+      listener && listener.call(this, _extends({}, event, { type: name }));
     }
   }, {
-    key: '_handleDetailedPhrase',
-    value: function _handleDetailedPhrase(event) {
-      console.log(event);
+    key: 'stop',
+    value: function stop() {
+      throw new Error('not supported');
+    }
+  }, {
+    key: 'start',
+    value: function () {
+      var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
+        var recognizer, _toPromise, eventListener, promises, error, listeningStarted, recognitionStarted, gotFirstHypothesis, speechHypothesis, speechDetailedPhrase, recognitionResult;
 
-      this._transitTo(AUDIO_END);
+        return regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                recognizer = this.recognizer = this.createRecognizer(window.localStorage.getItem('SPEECH_KEY'), this.lang);
+                _toPromise = toPromise(), eventListener = _toPromise.eventListener, promises = _objectWithoutProperties(_toPromise, ['eventListener']);
 
-      if (CognitiveSpeech.RecognitionStatus[event.Result.RecognitionStatus] === CognitiveSpeech.RecognitionStatus.Success) {
-        var nBest = event.Result.NBest;
 
+                recognizer.Recognize(eventListener);
+                this._aborted = false;
 
-        this.onresult && this.onresult(buildSpeechResult(event.Result.NBest[0].Display, event.Result.NBest[0].Confidence, true));
-      } else {
-        this.onerror && this.onerror({ error: event.Result.RecognitionStatus, type: 'error' });
-      }
-    }
-  }, {
-    key: '_handleHypothesis',
-    value: function _handleHypothesis(event) {
-      console.log(event);
+                _context3.next = 6;
+                return promises.recognitionTriggered;
 
-      this.onresult && this.onresult(buildSpeechResult(event.Result.Text, .5, false));
-    }
-  }, {
-    key: 'abort',
-    value: function abort() {
-      var _ref3 = this.recognizer || {},
-          AudioSource = _ref3.AudioSource;
+              case 6:
+                error = void 0;
+                _context3.next = 9;
+                return Promise.race([promises.listeningStarted, promises.recognitionEnded]);
 
-      console.log('ABORT: ' + AudioSource);
+              case 9:
+                listeningStarted = _context3.sent;
 
-      AudioSource && AudioSource.TurnOff();
-    }
-  }, {
-    key: 'handleRecognize',
-    value: function handleRecognize(event) {
-      try {
-        var name = event.Name;
+                if (!(listeningStarted.Name === 'RecognitionEndedEvent')) {
+                  _context3.next = 14;
+                  break;
+                }
 
+                // Possibly not authorized to use microphone
+                if (listeningStarted.Status === CognitiveSpeech.RecognitionCompletionStatus.AudioSourceError) {
+                  error = 'not-allowed';
+                } else {
+                  error = CognitiveSpeech.RecognitionCompletionStatus[listeningStarted.Status];
+                }
+                _context3.next = 51;
+                break;
 
-        console.log('handleRecognize: ' + name);
+              case 14:
+                this.emit('start');
 
-        switch (name) {
-          case 'ListeningStartedEvent':
-            this._transitTo(AUDIO_START);
-            break;
+                _context3.next = 17;
+                return promises.connectingToService;
 
-          case 'RecognitionEndedEvent':
-            if (event.Status !== CognitiveSpeech.RecognitionCompletionStatus.Success) {
-              this._transitTo(AUDIO_END);
-              this.onerror && this.onerror({ error: CognitiveSpeech.RecognitionCompletionStatus[event.Status], type: 'error' });
-            }
+              case 17:
+                _context3.next = 19;
+                return Promise.race([promises.recognitionStarted, promises.recognitionEnded]);
 
-            this._transitTo(END);
+              case 19:
+                recognitionStarted = _context3.sent;
 
-            break;
 
-          case 'RecognitionStartedEvent':
-            this._transitTo(SPEECH_START);
-            break;
+                this.emit('audiostart');
 
-          case 'RecognitionTriggeredEvent':
-            this._transitTo(START);
-            break;
+                if (!(recognitionStarted.Name === 'RecognitionEndedEvent')) {
+                  _context3.next = 25;
+                  break;
+                }
 
-          case 'SpeechEndDetectedEvent':
-            this._transitTo(SPEECH_END);
-            break;
+                // Possibly network error
+                if (recognitionStarted.Status === CognitiveSpeech.RecognitionCompletionStatus.ConnectError) {
+                  error = 'network';
+                } else {
+                  error = CognitiveSpeech.RecognitionCompletionStatus[recognitionStarted.Status];
+                }
+                _context3.next = 36;
+                break;
 
-          case 'SpeechStartDetectedEvent':
-            this._transitTo(SPEECH_START);
-            break;
+              case 25:
+                gotFirstHypothesis = void 0;
 
-          case 'SpeechHypothesisEvent':
-            this._handleHypothesis(event);
-            break;
+              case 26:
+                _context3.next = 28;
+                return Promise.race([promises.getSpeechHypothesisPromise(), promises.speechEndDetected]);
 
-          case 'SpeechDetailedPhraseEvent':
-            this._handleDetailedPhrase(event);
-            break;
+              case 28:
+                speechHypothesis = _context3.sent;
 
-          case 'ConnectingToServiceEvent':
-          case 'SpeechSimplePhraseEvent':
-            break;
+                if (!(speechHypothesis.Name === 'SpeechEndDetectedEvent')) {
+                  _context3.next = 31;
+                  break;
+                }
 
-          default:
-            console.warn('Unexpected event "' + name + '" from Cognitive Services, please file a bug to https://github.com/compulim/web-speech-cognitive-services');
-            break;
-        }
-      } catch (err) {
-        // Cognitive Services will hide all exceptions thrown in the event listener
-        // We need to show it otherwise when exception happen, we will not know what's going on
-        console.error(err);
-        throw err;
+                return _context3.abrupt('break', 35);
+
+              case 31:
+
+                if (!gotFirstHypothesis) {
+                  gotFirstHypothesis = true;
+                  this.emit('soundstart');
+                  this.emit('speechstart');
+                }
+
+                this.emit('result', buildSpeechResult(speechHypothesis.Result.Text, .5, false));
+
+              case 33:
+                _context3.next = 26;
+                break;
+
+              case 35:
+
+                if (gotFirstHypothesis) {
+                  this.emit('speechend');
+                  this.emit('soundend');
+                }
+
+              case 36:
+
+                this.emit('audioend');
+
+                if (!this._aborted) {
+                  _context3.next = 43;
+                  break;
+                }
+
+                error = 'aborted';
+
+                _context3.next = 41;
+                return promises.recognitionEnded;
+
+              case 41:
+                _context3.next = 51;
+                break;
+
+              case 43:
+                _context3.next = 45;
+                return Promise.race([promises.speechDetailedPhrase, promises.recognitionEnded]);
+
+              case 45:
+                speechDetailedPhrase = _context3.sent;
+
+                if (!(speechDetailedPhrase.Name !== 'RecognitionEndedEvent')) {
+                  _context3.next = 51;
+                  break;
+                }
+
+                recognitionResult = CognitiveSpeech.RecognitionStatus[speechDetailedPhrase.Result.RecognitionStatus];
+
+
+                if (recognitionResult === CognitiveSpeech.RecognitionStatus.Success) {
+                  this.emit('result', buildSpeechResult(speechDetailedPhrase.Result.NBest[0].Display, speechDetailedPhrase.Result.NBest[0].Confidence, true));
+                } else if (recognitionResult !== CognitiveSpeech.RecognitionStatus.NoMatch) {
+                  // Possibly silent or muted
+                  if (recognitionResult === CognitiveSpeech.RecognitionStatus.InitialSilenceTimeout) {
+                    error = 'no-speech';
+                  } else {
+                    error = speechDetailedPhrase.Result.RecognitionStatus;
+                  }
+                }
+
+                _context3.next = 51;
+                return promises.recognitionEnded;
+
+              case 51:
+
+                error && this.emit('error', { error: error });
+                this.emit('end');
+
+              case 53:
+              case 'end':
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function start() {
+        return _ref4.apply(this, arguments);
       }
-    }
-  }, {
-    key: 'start',
-    value: function start() {
-      this.recognizer = this.createRecognizer(window.localStorage.getItem('SPEECH_KEY'), this.lang);
 
-      this.recognizer.Recognize(this.handleRecognize.bind(this));
-      this._transitTo(START);
-    }
+      return start;
+    }()
   }, {
-    key: 'stop',
-    value: function stop() {
-      throw new Error('not supported');
-    }
-  }, {
     key: 'grammars',
@@ -336,3 +407,44 @@ get: function get() {
 
+function toPromise() {
+  var events = {
+    ConnectingToServiceEvent: new _eventAsPromise2.default(),
+    ListeningStartedEvent: new _eventAsPromise2.default(),
+    RecognitionEndedEvent: new _eventAsPromise2.default(),
+    RecognitionStartedEvent: new _eventAsPromise2.default(),
+    RecognitionTriggeredEvent: new _eventAsPromise2.default(),
+    SpeechDetailedPhraseEvent: new _eventAsPromise2.default(),
+    SpeechEndDetectedEvent: new _eventAsPromise2.default(),
+    SpeechHypothesisEvent: new _eventAsPromise2.default(),
+    SpeechSimplePhraseEvent: new _eventAsPromise2.default(),
+    SpeechStartDetectedEvent: new _eventAsPromise2.default()
+  };
+
+  return {
+    connectingToService: events.ConnectingToServiceEvent.upcoming(),
+    listeningStarted: events.ListeningStartedEvent.upcoming(),
+    recognitionEnded: events.RecognitionEndedEvent.upcoming(),
+    recognitionStarted: events.RecognitionStartedEvent.upcoming(),
+    recognitionTriggered: events.RecognitionTriggeredEvent.upcoming(),
+    speechDetailedPhrase: events.SpeechDetailedPhraseEvent.upcoming(),
+    speechEndDetected: events.SpeechEndDetectedEvent.upcoming(),
+    getSpeechHypothesisPromise: function getSpeechHypothesisPromise() {
+      return events.SpeechHypothesisEvent.upcoming();
+    },
+    speechSimplePhrase: events.SpeechSimplePhraseEvent.upcoming(),
+    speechStartDetected: events.SpeechStartDetectedEvent.upcoming(),
+    eventListener: function eventListener(event) {
+      var name = event.Name;
+
+      var eventAsPromise = events[name];
+
+      if (eventAsPromise) {
+        eventAsPromise.eventListener.call(null, event);
+      } else {
+        console.warn('Unexpected event "' + name + '" from Cognitive Services, please file a bug to https://github.com/compulim/web-speech-cognitive-services');
+      }
+    }
+  };
+}
+
 exports.default = CognitiveServicesSpeechRecognition;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/CognitiveServicesSpeechRecognition.js"],"names":["CognitiveSpeech","UNINIT","IDLE","START","AUDIO_START","SOUND_START","SPEECH_START","SPEECH_END","SOUND_END","AUDIO_END","END","EVENT_TYPES","buildSpeechResult","transcript","confidence","isFinal","result","results","type","CognitiveServicesSpeechRecognition","_lang","readyState","onaudiostart","onaudioend","onend","onerror","onnomatch","onresult","onsoundstart","onsoundend","onspeechstart","onspeechend","onstart","createRecognizer","subscriptionKeyOrTokenFetch","lang","navigator","language","mode","RecognitionMode","Interactive","platform","window","userAgent","name","osVersion","manufacturer","model","deviceVersion","config","RecognizerConfig","SpeechConfig","Context","OS","Device","SpeechResultFormat","Detailed","auth","CognitiveTokenAuthentication","authFetchEventID","CognitiveSubscriptionKeyAuthentication","CreateRecognizer","nextReadyState","lifecycleEvents","transition","eventListener","event","console","log","_transitTo","RecognitionStatus","Result","Success","nBest","NBest","Display","Confidence","error","Text","recognizer","AudioSource","TurnOff","Name","Status","RecognitionCompletionStatus","_handleHypothesis","_handleDetailedPhrase","warn","err","localStorage","getItem","Recognize","handleRecognize","bind","Error","nextGrammars","nextLang","nextContinuous","nextInterimResults","nextMaxAlternatives","nextServiceURI"],"mappings":"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","file":"CognitiveServicesSpeechRecognition.js","sourcesContent":["import * as CognitiveSpeech from 'microsoft-speech-browser-sdk';\nimport memoize from 'memoize-one';\n\nconst UNINIT = 0;\nconst IDLE = 1;\nconst START = 2;\nconst AUDIO_START = 3;\nconst SOUND_START = 4;\nconst SPEECH_START = 5;\nconst SPEECH_END = 6;\nconst SOUND_END = 7;\nconst AUDIO_END = 8;\nconst END = 9;\n\nconst EVENT_TYPES = [\n  null,\n  null,\n  'start',\n  'audiostart',\n  'soundstart',\n  'speechstart',\n  'speechend',\n  'soundend',\n  'audioend',\n  'end'\n];\n\nfunction buildSpeechResult(transcript, confidence, isFinal) {\n  const result = [{ confidence, transcript }];\n\n  result.isFinal = isFinal;\n\n  return { results: [result], type: 'result' };\n}\n\nclass CognitiveServicesSpeechRecognition {\n  constructor() {\n    this._lang = '';\n\n    this.readyState = 0;\n\n    this.onaudiostart = null;\n    this.onaudioend = null;\n    this.onend = null;\n    this.onerror = null;\n    this.onnomatch = null;\n    this.onresult = null;\n    this.onsoundstart = null;\n    this.onsoundend = null;\n    this.onspeechstart = null;\n    this.onspeechend = null;\n    this.onstart = null;\n\n    this.createRecognizer = memoize((\n      subscriptionKeyOrTokenFetch,\n      lang = navigator.language,\n      mode = CognitiveSpeech.RecognitionMode.Interactive\n    ) => {\n      const platform = window.navigator.userAgent;\n      const name = 'Browser';\n      const osVersion = VERSION;\n      const manufacturer = 'web-speech-cognitive-services';\n      const model = 'web-speech-cognitive-services';\n      const deviceVersion = VERSION;\n\n      const config = new CognitiveSpeech.RecognizerConfig(\n        new CognitiveSpeech.SpeechConfig(\n          new CognitiveSpeech.Context(\n            new CognitiveSpeech.OS(platform, name, osVersion),\n            new CognitiveSpeech.Device(manufacturer, model, deviceVersion)\n          )\n        ),\n        mode,\n        lang,\n        CognitiveSpeech.SpeechResultFormat.Detailed\n      );\n\n      let auth;\n\n      if (typeof subscriptionKeyOrTokenFetch === 'function') {\n        auth = new CognitiveSpeech.CognitiveTokenAuthentication(\n          async authFetchEventID => await subscriptionKeyOrTokenFetch(authFetchEventID, false),\n          async authFetchEventID => await subscriptionKeyOrTokenFetch(authFetchEventID, true)\n        );\n      } else {\n        auth = new CognitiveSpeech.CognitiveSubscriptionKeyAuthentication(subscriptionKeyOrTokenFetch);\n      }\n\n      return CognitiveSpeech.CreateRecognizer(config, auth);\n    });\n  }\n\n  get grammars() { return; }\n  set grammars(nextGrammars) {\n    // throw new Error('not supported');\n  }\n\n  get lang() { return this._lang; }\n  set lang(nextLang) { this._lang = nextLang; }\n\n  get continuous() { return false; }\n  set continuous(nextContinuous) { throw new Error('not supported'); }\n\n  get interimResults() { return true; }\n  set interimResults(nextInterimResults) {\n    if (!nextInterimResults) {\n      throw new Error('not supported');\n    }\n  }\n\n  get maxAlternatives() { return 1; }\n  set maxAlternatives(nextMaxAlternatives) { throw new Error('not supported'); }\n\n  get serviceURI() { return null; }\n  set serviceURI(nextServiceURI) { throw new Error('not supported'); }\n\n  _transitTo(nextReadyState) {\n    // console.log(`_transitTo: readyState = ${ this.readyState }, nextReadyState = ${ nextReadyState }`);\n\n    if (nextReadyState > this.readyState) {\n      const lifecycleEvents = [\n        null,\n        null,\n        this.onstart,\n        this.onaudiostart,\n        this.onsoundstart,\n        this.onspeechstart,\n        this.onspeechend,\n        this.onsoundend,\n        this.onaudioend,\n        this.onend\n      ];\n\n      if (\n        this.readyState === AUDIO_START\n        && nextReadyState >= AUDIO_END\n      ) {\n        // If soundstart, speechstart, speechend, and soundend are not fired after audiostart,\n        // we can skip them and just fire audioend directly\n        this.readyState = SOUND_END;\n      }\n\n      for (let transition = this.readyState + 1; transition <= nextReadyState; transition++) {\n        const eventListener = lifecycleEvents[transition];\n\n        // eventListener && console.log(`Firing \"${ EVENT_TYPES[transition] }\"`);\n        eventListener && eventListener({ type: EVENT_TYPES[transition] });\n      }\n\n      if (nextReadyState === END) {\n        this.readyState = IDLE;\n      } else {\n        this.readyState = nextReadyState;\n      }\n    }\n  }\n\n  _handleDetailedPhrase(event) {\n    console.log(event);\n\n    this._transitTo(AUDIO_END);\n\n    if (CognitiveSpeech.RecognitionStatus[event.Result.RecognitionStatus] === CognitiveSpeech.RecognitionStatus.Success) {\n      const { NBest: nBest } = event.Result;\n\n      this.onresult && this.onresult(buildSpeechResult(event.Result.NBest[0].Display, event.Result.NBest[0].Confidence, true));\n    } else {\n      this.onerror && this.onerror({ error: event.Result.RecognitionStatus, type: 'error' });\n    }\n  }\n\n  _handleHypothesis(event) {\n    console.log(event);\n\n    this.onresult && this.onresult(buildSpeechResult(event.Result.Text, .5, false));\n  }\n\n  abort() {\n    const { AudioSource } = this.recognizer || {};\n\n    console.log(`ABORT: ${ AudioSource }`);\n\n    AudioSource && AudioSource.TurnOff();\n  }\n\n  handleRecognize(event) {\n    try {\n      const { Name: name } = event;\n\n      console.log(`handleRecognize: ${ name }`);\n\n      switch (name) {\n      case 'ListeningStartedEvent':\n        this._transitTo(AUDIO_START);\n        break;\n\n      case 'RecognitionEndedEvent':\n        if (event.Status !== CognitiveSpeech.RecognitionCompletionStatus.Success) {\n          this._transitTo(AUDIO_END);\n          this.onerror && this.onerror({ error: CognitiveSpeech.RecognitionCompletionStatus[event.Status], type: 'error' });\n        }\n\n        this._transitTo(END);\n\n        break;\n\n      case 'RecognitionStartedEvent':\n        this._transitTo(SPEECH_START);\n        break;\n\n      case 'RecognitionTriggeredEvent':\n        this._transitTo(START);\n        break;\n\n      case 'SpeechEndDetectedEvent':\n        this._transitTo(SPEECH_END);\n        break;\n\n      case 'SpeechStartDetectedEvent':\n        this._transitTo(SPEECH_START);\n        break;\n\n      case 'SpeechHypothesisEvent':\n        this._handleHypothesis(event);\n        break;\n\n      case 'SpeechDetailedPhraseEvent':\n        this._handleDetailedPhrase(event);\n        break;\n\n      case 'ConnectingToServiceEvent':\n      case 'SpeechSimplePhraseEvent':\n        break;\n\n      default:\n        console.warn(`Unexpected event \\\"${ name }\\\" from Cognitive Services, please file a bug to https://github.com/compulim/web-speech-cognitive-services`);\n        break;\n      }\n    } catch (err) {\n      // Cognitive Services will hide all exceptions thrown in the event listener\n      // We need to show it otherwise when exception happen, we will not know what's going on\n      console.error(err);\n      throw err;\n    }\n  }\n\n  start() {\n    this.recognizer = this.createRecognizer(\n      window.localStorage.getItem('SPEECH_KEY'),\n      this.lang\n    );\n\n    this.recognizer.Recognize(this.handleRecognize.bind(this));\n    this._transitTo(START);\n  }\n\n  stop() {\n    throw new Error('not supported');\n  }\n}\n\nexport default CognitiveServicesSpeechRecognition\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/CognitiveServicesSpeechRecognition.js"],"names":["CognitiveSpeech","UNINIT","IDLE","START","AUDIO_START","SOUND_START","SPEECH_START","SPEECH_END","SOUND_END","AUDIO_END","END","EVENT_TYPES","buildSpeechResult","transcript","confidence","isFinal","result","results","type","CognitiveServicesSpeechRecognition","_lang","readyState","onaudiostart","onaudioend","onend","onerror","onnomatch","onresult","onsoundstart","onsoundend","onspeechstart","onspeechend","onstart","createRecognizer","subscriptionKeyOrTokenFetch","lang","navigator","language","mode","RecognitionMode","Interactive","platform","window","userAgent","name","osVersion","manufacturer","model","deviceVersion","config","RecognizerConfig","SpeechConfig","Context","OS","Device","SpeechResultFormat","Detailed","auth","CognitiveTokenAuthentication","authFetchEventID","CognitiveSubscriptionKeyAuthentication","CreateRecognizer","recognizer","AudioSource","TurnOff","_aborted","event","listener","call","Error","localStorage","getItem","toPromise","eventListener","promises","Recognize","recognitionTriggered","error","Promise","race","listeningStarted","recognitionEnded","Name","Status","RecognitionCompletionStatus","AudioSourceError","emit","connectingToService","recognitionStarted","ConnectError","gotFirstHypothesis","getSpeechHypothesisPromise","speechEndDetected","speechHypothesis","Result","Text","speechDetailedPhrase","recognitionResult","RecognitionStatus","Success","NBest","Display","Confidence","NoMatch","InitialSilenceTimeout","nextGrammars","nextLang","nextContinuous","nextInterimResults","nextMaxAlternatives","nextServiceURI","events","ConnectingToServiceEvent","EventAsPromise","ListeningStartedEvent","RecognitionEndedEvent","RecognitionStartedEvent","RecognitionTriggeredEvent","SpeechDetailedPhraseEvent","SpeechEndDetectedEvent","SpeechHypothesisEvent","SpeechSimplePhraseEvent","SpeechStartDetectedEvent","upcoming","speechSimplePhrase","speechStartDetected","eventAsPromise","console","warn"],"mappings":"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","file":"CognitiveServicesSpeechRecognition.js","sourcesContent":["import * as CognitiveSpeech from 'microsoft-speech-browser-sdk';\nimport EventAsPromise from 'event-as-promise';\nimport memoize from 'memoize-one';\n\nconst UNINIT = 0;\nconst IDLE = 1;\nconst START = 2;\nconst AUDIO_START = 3;\nconst SOUND_START = 4;\nconst SPEECH_START = 5;\nconst SPEECH_END = 6;\nconst SOUND_END = 7;\nconst AUDIO_END = 8;\nconst END = 9;\n\nconst EVENT_TYPES = [\n  null,\n  null,\n  'start',\n  'audiostart',\n  'soundstart',\n  'speechstart',\n  'speechend',\n  'soundend',\n  'audioend',\n  'end'\n];\n\nfunction buildSpeechResult(transcript, confidence, isFinal) {\n  const result = [{ confidence, transcript }];\n\n  result.isFinal = isFinal;\n\n  return { results: [result], type: 'result' };\n}\n\nclass CognitiveServicesSpeechRecognition {\n  constructor() {\n    this._lang = '';\n\n    this.readyState = 0;\n\n    this.onaudiostart = null;\n    this.onaudioend = null;\n    this.onend = null;\n    this.onerror = null;\n    this.onnomatch = null;\n    this.onresult = null;\n    this.onsoundstart = null;\n    this.onsoundend = null;\n    this.onspeechstart = null;\n    this.onspeechend = null;\n    this.onstart = null;\n\n    this.createRecognizer = memoize((\n      subscriptionKeyOrTokenFetch,\n      lang = navigator.language,\n      mode = CognitiveSpeech.RecognitionMode.Interactive\n    ) => {\n      const platform = window.navigator.userAgent;\n      const name = 'Browser';\n      const osVersion = VERSION;\n      const manufacturer = 'web-speech-cognitive-services';\n      const model = 'web-speech-cognitive-services';\n      const deviceVersion = VERSION;\n\n      const config = new CognitiveSpeech.RecognizerConfig(\n        new CognitiveSpeech.SpeechConfig(\n          new CognitiveSpeech.Context(\n            new CognitiveSpeech.OS(platform, name, osVersion),\n            new CognitiveSpeech.Device(manufacturer, model, deviceVersion)\n          )\n        ),\n        mode,\n        lang,\n        CognitiveSpeech.SpeechResultFormat.Detailed\n      );\n\n      let auth;\n\n      if (typeof subscriptionKeyOrTokenFetch === 'function') {\n        auth = new CognitiveSpeech.CognitiveTokenAuthentication(\n          async authFetchEventID => await subscriptionKeyOrTokenFetch(authFetchEventID, false),\n          async authFetchEventID => await subscriptionKeyOrTokenFetch(authFetchEventID, true)\n        );\n      } else {\n        auth = new CognitiveSpeech.CognitiveSubscriptionKeyAuthentication(subscriptionKeyOrTokenFetch);\n      }\n\n      return CognitiveSpeech.CreateRecognizer(config, auth);\n    });\n  }\n\n  get grammars() { return; }\n  set grammars(nextGrammars) {\n    // throw new Error('not supported');\n  }\n\n  get lang() { return this._lang; }\n  set lang(nextLang) { this._lang = nextLang; }\n\n  get continuous() { return false; }\n  set continuous(nextContinuous) { throw new Error('not supported'); }\n\n  get interimResults() { return true; }\n  set interimResults(nextInterimResults) {\n    if (!nextInterimResults) {\n      throw new Error('not supported');\n    }\n  }\n\n  get maxAlternatives() { return 1; }\n  set maxAlternatives(nextMaxAlternatives) { throw new Error('not supported'); }\n\n  get serviceURI() { return null; }\n  set serviceURI(nextServiceURI) { throw new Error('not supported'); }\n\n  abort() {\n    // TODO: Should redesign how to stop a recognition session\n    //       After abort is called, we should not saw it is a \"success\", \"silent\", or \"no match\"\n    const { AudioSource } = this.recognizer || {};\n\n    AudioSource && AudioSource.TurnOff();\n\n    this._aborted = true;\n  }\n\n  emit(name, event) {\n    const listener = this[`on${ name }`];\n\n    listener && listener.call(this, { ...event, type: name });\n  }\n\n  stop() {\n    throw new Error('not supported');\n  }\n\n  async start() {\n    const recognizer = this.recognizer = this.createRecognizer(\n      window.localStorage.getItem('SPEECH_KEY'),\n      this.lang\n    );\n\n    const { eventListener, ...promises } = toPromise();\n\n    recognizer.Recognize(eventListener);\n    this._aborted = false;\n\n    await promises.recognitionTriggered;\n\n    let error;\n\n    const listeningStarted = await Promise.race([\n      promises.listeningStarted,\n      promises.recognitionEnded\n    ]);\n\n    if (listeningStarted.Name === 'RecognitionEndedEvent') {\n      // Possibly not authorized to use microphone\n      if (listeningStarted.Status === CognitiveSpeech.RecognitionCompletionStatus.AudioSourceError) {\n        error = 'not-allowed';\n      } else {\n        error = CognitiveSpeech.RecognitionCompletionStatus[listeningStarted.Status];\n      }\n    } else {\n      this.emit('start');\n\n      await promises.connectingToService;\n\n      const recognitionStarted = await Promise.race([\n        promises.recognitionStarted,\n        promises.recognitionEnded\n      ]);\n\n      this.emit('audiostart');\n\n      if (recognitionStarted.Name === 'RecognitionEndedEvent') {\n        // Possibly network error\n        if (recognitionStarted.Status === CognitiveSpeech.RecognitionCompletionStatus.ConnectError) {\n          error = 'network';\n        } else {\n          error = CognitiveSpeech.RecognitionCompletionStatus[recognitionStarted.Status];\n        }\n      } else {\n        let gotFirstHypothesis;\n\n        for (;;) {\n          const speechHypothesis = await Promise.race([\n            promises.getSpeechHypothesisPromise(),\n            promises.speechEndDetected\n          ]);\n\n          if (speechHypothesis.Name === 'SpeechEndDetectedEvent') {\n            break;\n          }\n\n          if (!gotFirstHypothesis) {\n            gotFirstHypothesis = true;\n            this.emit('soundstart');\n            this.emit('speechstart');\n          }\n\n          this.emit('result', buildSpeechResult(speechHypothesis.Result.Text, .5, false));\n        }\n\n        if (gotFirstHypothesis) {\n          this.emit('speechend');\n          this.emit('soundend');\n        }\n      }\n\n      this.emit('audioend');\n\n      if (this._aborted) {\n        error = 'aborted';\n\n        await promises.recognitionEnded;\n      } else {\n        const speechDetailedPhrase = await Promise.race([\n          promises.speechDetailedPhrase,\n          promises.recognitionEnded\n        ]);\n\n        if (speechDetailedPhrase.Name !== 'RecognitionEndedEvent') {\n          const recognitionResult = CognitiveSpeech.RecognitionStatus[speechDetailedPhrase.Result.RecognitionStatus];\n\n          if (recognitionResult === CognitiveSpeech.RecognitionStatus.Success) {\n            this.emit('result', buildSpeechResult(speechDetailedPhrase.Result.NBest[0].Display, speechDetailedPhrase.Result.NBest[0].Confidence, true));\n          } else if (recognitionResult !== CognitiveSpeech.RecognitionStatus.NoMatch) {\n            // Possibly silent or muted\n            if (recognitionResult === CognitiveSpeech.RecognitionStatus.InitialSilenceTimeout) {\n              error = 'no-speech';\n            } else {\n              error = speechDetailedPhrase.Result.RecognitionStatus;\n            }\n          }\n\n          await promises.recognitionEnded;\n        }\n      }\n    }\n\n    error && this.emit('error', { error });\n    this.emit('end');\n  }\n}\n\nfunction toPromise() {\n  const events = {\n    ConnectingToServiceEvent: new EventAsPromise(),\n    ListeningStartedEvent: new EventAsPromise(),\n    RecognitionEndedEvent: new EventAsPromise(),\n    RecognitionStartedEvent: new EventAsPromise(),\n    RecognitionTriggeredEvent: new EventAsPromise(),\n    SpeechDetailedPhraseEvent: new EventAsPromise(),\n    SpeechEndDetectedEvent: new EventAsPromise(),\n    SpeechHypothesisEvent: new EventAsPromise(),\n    SpeechSimplePhraseEvent: new EventAsPromise(),\n    SpeechStartDetectedEvent: new EventAsPromise()\n  };\n\n  return {\n    connectingToService: events.ConnectingToServiceEvent.upcoming(),\n    listeningStarted: events.ListeningStartedEvent.upcoming(),\n    recognitionEnded: events.RecognitionEndedEvent.upcoming(),\n    recognitionStarted: events.RecognitionStartedEvent.upcoming(),\n    recognitionTriggered: events.RecognitionTriggeredEvent.upcoming(),\n    speechDetailedPhrase: events.SpeechDetailedPhraseEvent.upcoming(),\n    speechEndDetected: events.SpeechEndDetectedEvent.upcoming(),\n    getSpeechHypothesisPromise: () => events.SpeechHypothesisEvent.upcoming(),\n    speechSimplePhrase: events.SpeechSimplePhraseEvent.upcoming(),\n    speechStartDetected: events.SpeechStartDetectedEvent.upcoming(),\n    eventListener: event => {\n      const { Name: name } = event;\n      const eventAsPromise = events[name];\n\n      if (eventAsPromise) {\n        eventAsPromise.eventListener.call(null, event);\n      } else {\n        console.warn(`Unexpected event \\\"${ name }\\\" from Cognitive Services, please file a bug to https://github.com/compulim/web-speech-cognitive-services`);\n      }\n    }\n  };\n}\n\nexport default CognitiveServicesSpeechRecognition\n"]}

package.json

 {
   "name": "web-speech-cognitive-services",
-  "version": "0.0.1-master.e70a05d",
+  "version": "0.0.1-master.f80884e",
   "description": "",
@@ -31,8 +31,10 @@ "keywords": [],
     "babel-plugin-version-transform": "^1.0.0",
+    "babel-polyfill": "^6.26.0",
     "babel-preset-stage-3": "^6.24.1",
     "classnames": "^2.2.6",
+    "event-as-promise": "^1.0.3",
     "glamor": "^2.20.40",
     "jest": "^22.4.4",
     "lerna": "^2.11.0",
-    "microsoft-speech-browser-sdk": "0.0.12",
+    "microsoft-speech-browser-sdk": "^0.0.12",
     "react": "^16.4.1",
@@ -39,0 +41,0 @@ "react-dictate-button": "^1.0.0",

README.md

 # web-speech-cognitive-services
 
-[![npm version](https://badge.fury.io/js/we-bspeech-cognitive-services.svg)](https://badge.fury.io/js/we-bspeech-cognitive-services) [![Build Status](https://travis-ci.org/compulim/we-bspeech-cognitive-services.svg?branch=master)](https://travis-ci.org/compulim/web-speech-cognitive-services)
+[![npm version](https://badge.fury.io/js/web-speech-cognitive-services.svg)](https://badge.fury.io/js/web-speech-cognitive-services) [![Build Status](https://travis-ci.org/compulim/web-speech-cognitive-services.svg?branch=master)](https://travis-ci.org/compulim/web-speech-cognitive-services)
 
 Polyfill Web Speech API with Cognitive Services.
 
-## Event lifecycle mapping from Cognitive Services
+This scaffold is provided by [`react-component-template`](https://github.com/compulim/react-component-template/).
 
-| # | WebSpeech | Cognitive Services | Notes |
-| - | - | - | - |
-| 1 | `start` | `RecognitionTriggeredEvent` | |
-| 2 | `audiostart` | `ListeningStartedEvent` | |
-| 3 | | `ConnectingToServiceEvent` | |
-| 4 | `soundstart`, `speechstart` | `RecognitionStartedEvent` | |
-| 5 | `onresult(isFinal = false)` | `SpeechHypothesisEvent` | |
-| 6 | `speechend`, `soundend`, `audioend` | `SpeechEndDetectedEvent` | `speechend` and `soundend` only fire if either `speechstart` and `soundstart` was fired |
-| 7 | `onresult(isFinal = true)`, `onerror` | `SpeechSimplePhraseEvent` | |
-| 8 | `end` | `RecognitionEndedEvent` | |
+# Demo
 
-### Scenarios
+Try out our demo at https://compulim.github.io/web-speech-cognitive-services?s=your-subscription-key.
 
-* Happy path
+We use [`react-dictate-button`](https://github.com/compulim/react-dictate-button/) to quickly setup the playground.
+
+# Background
+
+Web Speech API is not widely adopted on popular browsers and platforms. Polyfilling the API using cloud services is a great way to enable wider adoption. Nonetheless, Web Speech API in Google Chrome is also backed by cloud services.
+
+Microsoft Azure [Cognitive Services Speech-to-Text](https://azure.microsoft.com/en-us/services/cognitive-services/speech-to-text/) service provide speech recognition with great accuracy. But unfortunately, the APIs are not based on Web Speech API.
+
+This package will polyfill Web Speech API by turning Cognitive Services Speech-to-Text API into Web Speech API. We test this package with popular combination of platforms and browsers.
+
+# Test matrix
+
+Browsers are all latest as of 2018-06-28, except:
+* macOS was 10.13.1 (2017-10-31), instead of 10.13.5
+   * Tthere should be no change on the matrix since Safari does not support Web Speech API
+* Xbox was tested on Insider build (1806)
+
+Overall in point form:
+
+* With Web Speech API only, web dev can enable speech recognition on most popular platforms, except iOS
+   * iOS: No browsers on iOS support Web Speech API
+   * Some platforms requires non-default browser
+* With Cognitive Services Speech-to-Text, all popular platforms with their default browsers are supported
+   * iOS: Chrome and Edge does not support Cognitive Services because WebRTC is disabled
+
+| Platform             | OS                           | Browser              | Cognitive Services (WebRTC) | Web Speech API                          |
+| -                    | -                            | -                    | -                           | -                                       |
+| PC                   | Windows 10 (1803)            | Chrome 67.0.3396.99  | Yes                         | Yes                                     |
+| PC                   | Windows 10 (1803)            | Edge 42.17134.1.0    | Yes                         | No, `SpeechRecognition` not implemented |
+| PC                   | Windows 10 (1803)            | Firefox 61.0         | Yes                         | No, `SpeechRecognition` not implemented |
+| MacBook Pro          | macOS High Sierra 10.13.1    | Chrome 67.0.3396.99  | Yes                         | Yes                                     |
+| MacBook Pro          | macOS High Sierra 10.13.1    | Safari 11.0.1        | Yes                         | No, `SpeechRecognition` not implemented |
+| Apple iPhone X       | iOS 11.4                     | Chrome 67.0.3396.87  | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+| Apple iPhone X       | iOS 11.4                     | Edge 42.2.2.0        | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+| Apple iPhone X       | iOS 11.4                     | Safari               | Yes                         | No, `SpeechRecognition` not implemented |
+| Apple iPod (6th gen) | iOS 11.4                     | Chrome 67.0.3396.87  | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+| Apple iPod (6th gen) | iOS 11.4                     | Edge 42.2.2.0        | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+| Apple iPod (6th gen) | iOS 11.4                     | Safari               | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+| Google Pixel 2       | Android 8.1.0                | Chrome 67.0.3396.87  | Yes                         | Yes                                     |
+| Google Pixel 2       | Android 8.1.0                | Edge 42.0.0.2057     | Yes                         | Yes                                     |
+| Google Pixel 2       | Android 8.1.0                | Firefox 60.1.0       | Yes                         | Yes                                     |
+| Microsoft Lumia 950  | Windows 10 (1709)            | Edge 40.15254.489.0  | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+| Microsoft Xbox One   | Windows 10 (1806) 17134.4054 | Edge 42.17134.4054.0 | No, `AudioSourceError`      | No, `SpeechRecognition` not implemented |
+
+## Event lifecycle scenarios
+
+We test multiple scenarios to make sure the package polyfill Web Speech API correctly. Following are events and its firing order.
+
+* [Happy path](#happy-path)
+* [Abort during recognition](#abort-during-recognition)
+* [Network issues](#network-issues)
+* [Audio muted or volume too low](#audio-muted-or-volume-too-low)
+* [No speech is recognized](#no-speech-is-recognized)
+* [Not authorized to use microphone](#not-authorized-to-use-microphone)
+
+### Happy path
+
+Everything works, including multiple interim results.
+
+* Cognitive Services
    1. `RecognitionTriggeredEvent`
@@ -29,11 +79,64 @@ 2. `ListeningStartedEvent`
    6. `SpeechEndDetectedEvent`
-   7. `SpeechSimplePhraseEvent`
+   7. `SpeechDetailedPhraseEvent`
    8. `RecognitionEndedEvent`
-* Network issues
+* Web Speech API
+   1. `start`
+   2. `audiostart`
+   3. `soundstart`
+   4. `speechstart`
+   5. `result` (multiple times)
+   6. `speechend`
+   7. `soundend`
+   8. `audioend`
+   9. `result(results = [{ isFinal = true }])`
+   10. `end`
+
+### Abort during recognition
+
+#### Abort before first recognition is made
+
+* Cognitive Services
+   * Essentially muted the speech, that could still result in success, silent, or no match
+* Web Speech API
+   1. `start`
+   2. `audiostart`
+   8. `audioend`
+   9. `error(error = 'aborted')`
+   10. `end`
+
+#### Abort after some speech is recognized
+
+* Cognitive Services
+   * Essentially muted the speech, that could still result in success, silent, or no match
+* Web Speech API
+   1. `start`
+   2. `audiostart`
+   3. `soundstart` (optional)
+   4. `speechstart` (optional)
+   5. `result` (optional)
+   6. `speechend` (optional)
+   7. `soundend` (optional)
+   8. `audioend`
+   9. `error(error = 'aborted')`
+   10. `end`
+
+### Network issues
+
+Turn on airplane mode.
+
+* Cognitive Services
    1. `RecognitionTriggeredEvent`
    2. `ListeningStartedEvent`
    3. `ConnectingToServiceEvent`
-   4. `SpeechSimplePhraseEvent`
-   5. `RecognitionEndedEvent`
-* Audio muted or volume too low
+   5. `RecognitionEndedEvent(Result.RecognitionStatus = 'ConnectError')`
+* Web Speech API
+   1. `start`
+   2. `audiostart`
+   3. `audioend`
+   4. `error(error = 'network')`
+   5. `end`
+
+### Audio muted or volume too low
+
+* Cognitive Services
    1. `RecognitionTriggeredEvent`
@@ -44,5 +147,16 @@ 2. `ListeningStartedEvent`
    5. `SpeechEndDetectedEvent`
-   6. `SpeechSimplePhraseEvent(Result.RecognitionStatus = 'InitialSilenceTimeout')`
+   6. `SpeechDetailedPhraseEvent(Result.RecognitionStatus = 'InitialSilenceTimeout')`
    7. `RecognitionEndedEvent`
-* Failed to recognize speech (a.k.a. no match)
+* Web Speech API
+   1. `start`
+   2. `audiostart`
+   3. `audioend`
+   4. `error(error = 'no-speech')`
+   5. `end`
+
+### No speech is recognized
+
+Some sounds are heard, but they cannot be recognized as text. There could be some interim results with recognized text, but the confidence is so low it dropped out of final result.
+
+* Cognitive Services
    1. `RecognitionTriggeredEvent`
@@ -54,16 +168,41 @@ 2. `ListeningStartedEvent`
    6. `SpeechEndDetectedEvent`
-   7. `SpeechSimplePhraseEvent(Result.RecognitionStatus = 'NoMatch')`
+   7. `SpeechDetailedPhraseEvent(Result.RecognitionStatus = 'NoMatch')`
    8. `RecognitionEndedEvent`
-* User abort
-   * Essentially muted the speech, that could result in success, silent, or no match
-* Not authorized to use microphone
+* Web Speech API
+   1. `start`
+   2. `audiostart`
+   3. `soundstart`
+   4. `speechstart`
+   5. `result`
+   6. `speechend`
+   7. `soundend`
+   8. `audioend`
+   9. `end`
+
+> Note: the Web Speech API has `onnomatch` event, but unfortunately, Google Chrome did not fire this event.
+
+### Not authorized to use microphone
+
+The user click "deny" on the permission dialog, or there are no microphone detected in the system.
+
+* Cognitive Services
    1. `RecognitionTriggeredEvent`
    2. `RecognitionEndedEvent(Result.RecognitionStatus = 'AudioSourceError')`
+* Web Speech API
+   1. `error(error = 'not-allowed')`
+   2. `end`
 
+# Known issues
+
+* Interim results do not return confidence, final result do have confidence
+   * We always return `0.5` for interim results
+* Cognitive Services support grammar list but not in JSGF format, more work to be done in this area
+   * Although Google Chrome support setting the grammar list, it seems the grammar list is not used at all
+
 # Contributions
 
-Like us? [Star](https://github.com/compulim/we-bspeech-cognitive-services/stargazers) us.
+Like us? [Star](https://github.com/compulim/web-speech-cognitive-services/stargazers) us.
 
-Want to make it better? [File](https://github.com/compulim/we-bspeech-cognitive-services/issues) us an issue.
+Want to make it better? [File](https://github.com/compulim/web-speech-cognitive-services/issues) us an issue.
 
 Don't like something you see? [Submit](https://github.com/compulim/web-speech-cognitive-services/pulls) a pull request.

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

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

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

52458

increased by40.68%

Lines of code

363

increased by29.64%

Number of lines in readme file

206

increased by207.46%

Worsened metrics

Dev dependency count

18

increased by12.5%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes