pxt-common-packages 9.4.1 → 9.4.5

package/libs/text-to-speech/pxt.json

@@ -0,0 +1,14 @@
+{
+    "name": "text-to-speech",
+    "description": "Browser-only text to speech support",
+    "files": [
+        "shims.d.ts",
+        "tts.ts"
+    ],
+    "testFiles": [
+    ],
+    "public": true,
+    "dependencies": {
+        "core": "file:../core"
+    }
+}

package/libs/text-to-speech/shims.d.ts

@@ -0,0 +1,47 @@
+//% icon="\uf075"
+//% color="#f59c16"
+//% block="Text to Speech"
+declare namespace tts {
+    //% shim=tts::_speakAsync promise
+    function speak(text: string, pitch?: number, rate?: number, volume?: number, language?: string, onStart?: () => void, onBoundary?: (offset: number, nextWord: string, fullText: string) => void): void;
+
+    //% shim=tts::_getLanguageCode
+    function getLanguageCode(): string;
+
+    /**
+     * Pauses the current text being spoken. Any calls waiting for the text to finish
+     * will not return until the text is either resumed or cancelled.
+     */
+    //% shim=tts::_pause
+    //% blockId=tts_pause
+    //% block="pause speech"
+    //% weight=90
+    function pause(): void;
+
+    /**
+     * Returns true if the text to speech is currently paused
+     */
+    //% shim=tts::_isPaused
+    //% blockId=tts_isPaused
+    //% block="is speech paused"
+    //% weight=60
+    function isPaused(): boolean;
+
+    /**
+     * Resumes the current text being spoken if in the paused state.
+     */
+    //% shim=tts::_resume
+    //% blockId=tts_resume
+    //% block="resume speech"
+    //% weight=80
+    function resume(): void;
+
+    /**
+     * Cancels all text currently being spoken and any that has been queued.
+     */
+    //% shim=tts::_cancel
+    //% blockId=tts_cancel
+    //% block="cancel speech"
+    //% weight=70
+    function cancel(): void;
+}

package/libs/text-to-speech/sim/tts.ts

@@ -0,0 +1,72 @@
+namespace pxsim.tts {
+    export function _getLanguageCode() {
+        return window.navigator.language;
+    }
+
+    export function _speakAsync(text: string, pitch?: number, rate?: number, volume?: number, language?: string, onStart?: RefAction, onBoundary?: RefAction): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            const utterance = new SpeechSynthesisUtterance(text);
+            utterance.voice = getVoiceForLanguage(language || _getLanguageCode());
+
+            if (pitch != undefined) utterance.pitch = pitch;
+            if (rate != undefined) utterance.rate = rate;
+            if (volume != undefined) utterance.volume = volume;
+
+            utterance.onend = () => resolve();
+            utterance.onerror = reject;
+
+            if (onStart) {
+                utterance.onstart = () => runtime.runFiberAsync(onStart);
+            }
+
+            if (onBoundary) {
+                utterance.onboundary = event => {
+                    const offset = event.charIndex;
+                    const nextWord = text.substring(offset).split(/\s/).shift();
+
+                    runtime.runFiberAsync(onBoundary, offset, nextWord, text);
+                }
+            }
+
+            speechSynthesis.speak(utterance);
+        });
+    }
+
+    export function _pause() {
+        speechSynthesis.pause();
+    }
+
+    export function _isPaused(): boolean {
+        return speechSynthesis.paused;
+    }
+
+    export function _resume() {
+        speechSynthesis.resume();
+    }
+
+    export function _cancel() {
+        speechSynthesis.cancel();
+    }
+
+    function getVoiceForLanguage(language: string): SpeechSynthesisVoice {
+        language = language.toLowerCase();
+        const generalCode = language.substring(0, 2);
+
+        let bestMatch: SpeechSynthesisVoice;
+        let bestNonlocalMatch: SpeechSynthesisVoice;
+
+        for (const voice of speechSynthesis.getVoices()) {
+            const current = voice.lang.toLowerCase();
+            if (current === language) {
+                if (voice.localService) return voice;
+                else bestNonlocalMatch = voice;
+            }
+            else if (current.substring(0, 2) === generalCode) {
+                if (!bestMatch && voice.localService) bestMatch = voice;
+                if (!bestNonlocalMatch && !voice.localService) bestNonlocalMatch = voice
+            }
+        }
+
+        return bestMatch || bestNonlocalMatch || (language !== "en-us" ? getVoiceForLanguage("en-US") : undefined);
+    }
+}

package/libs/text-to-speech/tts.ts

@@ -0,0 +1,70 @@
+namespace tts {
+    class TextToSpeechState {
+        boundaryListeners: ((offset: number, nextWord: string, fullText: string) => void)[];
+
+        constructor() {
+            this.boundaryListeners = [];
+        }
+    }
+
+    let state: TextToSpeechState;
+
+    /**
+     * Runs code each time a word or sentence boundary is reached in text being spoken
+     */
+    //% blockId=tts_onWordSpoken
+    //% block="on word spoken from $fullText at $offset with $nextWord"
+    //% draggableParameters="reporter"
+    //% weight=10
+    export function onWordSpoken(handler: (offset: number, nextWord: string, fullText: string) => void) {
+        getState().boundaryListeners.push(handler);
+    }
+
+    /**
+     * Speak some text using the computer's text to speech voice and pause until the speaking has finished.
+     * If some text is already being spoken, this text will be queued until the other text finishes.
+     *
+     * @param text The text to speak
+     * @param volume The volume to speak at
+     * @param pitch A pitch modifier for moving the pitch of text up or down
+     * @param rate The rate at which the text will be spoken; higher is faster
+     * @param language The ISO language code for the text to be spoken; defaults to the system language
+     */
+    //% blockId=tts_speakText
+    //% block="speak $text||with volume $volume pitch $pitch rate $rate language $language"
+    //% inlineInputMode=inline
+    //% volume.min=0
+    //% volume.max=255
+    //% volume.defl=128
+    //% pitch.min=0
+    //% pitch.max=255
+    //% pitch.defl=128
+    //% rate.min=0
+    //% rate.max=255
+    //% rate.defl=25
+    //% weight=100
+    export function speakText(text: string, volume = 128, pitch = 128, rate = 25, language?: string) {
+        // Ranges from 0 to 1
+        volume = Math.map(Math.clamp(0, 255, volume), 0, 255, 0, 1);
+        // Ranges from 0 to 2
+        pitch = Math.map(Math.clamp(0, 255, pitch), 0, 255, 0, 2);;
+        // Ranges from 0.1 to 10
+        rate = Math.map(Math.clamp(0, 255, rate), 0, 255, 0.1, 10);
+
+        tts.speak(text, pitch, rate, volume, language, undefined, onBoundary);
+    }
+
+    function onBoundary(offset: number, nextWord: string, fullText: string) {
+        for (const handler of getState().boundaryListeners) {
+            control.runInParallel(() => handler(offset, nextWord, fullText))
+        }
+    }
+
+    function getState() {
+        if (!state) {
+            state = new TextToSpeechState();
+        }
+
+        return state;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pxt-common-packages",
-  "version": "9.4.1",
+  "version": "9.4.5",
   "description": "Microsoft MakeCode (PXT) common packages",
   "keywords": [
     "MakeCode",