Generate narration with Text-To-Speech technology. 

Generate narration with Text-To-Speech technology

james-hu

tts-narrator

Object.defineProperty(exports, "__esModule", { value: true });

exports.ScriptProcessor = exports.scriptProcessorFlags = exports.TtsServiceType = void 0;

/* eslint-disable @typescript-eslint/explicit-module-boundary-types */

const fs = (0, tslib_1.__importStar)(require("fs"));

const path_1 = (0, tslib_1.__importDefault)(require("path"));

const murmurhash = (0, tslib_1.__importStar)(require("murmurhash"));

const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));

const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));

const command_1 = require("@oclif/command");

const oclif_utils_1 = require("@handy-common-utils/oclif-utils");

const multi_integer_range_1 = require("multi-integer-range");

const azure_tts_service_1 = require("./azure-tts-service");

const narration_script_1 = require("./narration-script");

const audio_utils_1 = require("./audio-utils");

})(TtsServiceType = exports.TtsServiceType || (exports.TtsServiceType = {}));

 * CLI flags that are required/used by the ScriptProcessor.

    debug: command_1.flags.boolean({ char: 'd', description: 'output debug information' }),

    quiet: command_1.flags.boolean({ char: 'q', description: 'output warn and error information only' }),

    service: command_1.flags.string({ char: 's', options: Object.entries(TtsServiceType).map(([_name, value]) => value), description: 'text-to-speech service to use' }),

    'subscription-key': command_1.flags.string({ char: 'k', description: 'Azure Speech service subscription key' }),

    'subscription-key-env': command_1.flags.string({ description: 'Name of the environment variable that holds the subscription key' }),

    region: command_1.flags.string({ char: 'r', description: 'region of the text-to-speech service' }),

    play: command_1.flags.boolean({ char: 'p', default: true, allowNo: true, description: 'play generated audio' }),

    interactive: command_1.flags.boolean({ char: 'i', default: false, description: 'wait for key press before entering each section' }),

    overwrite: command_1.flags.boolean({ char: 'o', default: false, description: 'always overwrite previously generated audio files' }),

    'dry-run': command_1.flags.boolean({ default: false, description: 'don\'t try to generate or play audio' }),

    ssml: command_1.flags.boolean({ default: false, exclusive: ['quiet'], description: 'display generated SSML' }),

    chapters: command_1.flags.string({ description: 'list of chapters to process, examples: "1-10,13,15", "4-"' }),

    sections: command_1.flags.string({ description: 'list of sections to process, examples: "1-10,13,15", "5-"' }),

        this.scriptFilePath = scriptFilePath;

        this.cliConsole = (0, oclif_utils_1.cliConsoleWithColour)(this.flags, chalk_1.default);

        const hashNumber = murmurhash.v3(ssml, 2894);

        this._script = await (0, narration_script_1.loadScript)(this.scriptFilePath);

        this.cliConsole.debug(`Loaded script from ${this.scriptFilePath}`);

        const chapterRangeFlag = this.flags.chapters;

                this.chapterRange = new multi_integer_range_1.MultiRange(chapterRangeFlag);

                throw new Error(`Invalid chapter range '${chapterRangeFlag}': ${error}`);

        const sectionRangeFlag = this.flags.sections;

                this.sectionRange = new multi_integer_range_1.MultiRange(sectionRangeFlag);

                throw new Error(`Invalid section range '${sectionRangeFlag}': ${error}`);

    async initialiseTtsServiceIfNeeded() {

            const ttsServiceType = (_a = this.flags.service) !== null && _a !== void 0 ? _a : this._script.settings.service;

                case TtsServiceType.Azure:

                    this.ttsService = new azure_tts_service_1.AzureTtsService();

                    this.audioGenerationOptions = {

                        subscriptionKey: (_b = this.flags['subscription-key']) !== null && _b !== void 0 ? _b : (this.flags['subscription-key-env'] ? process.env[this.flags['subscription-key-env']] : undefined),

                        serviceRegion: this.flags.region,

                    throw new Error(`Unknown TTS service: ${ttsServiceType}`);

    async determineAudioFilePath(ssmlHash, _paragraph) {

        const audioFileFolder = this._script.scriptFilePath.split('.').slice(0, -1).join('.') + '.tts';

        if (!fs.existsSync(audioFileFolder)) {

            fs.mkdirSync(audioFileFolder);

            fs.mkdirSync(audioFileFolder, { recursive: true });

        const audioFilePath = path_1.default.join(audioFileFolder, `${ssmlHash}.mp3`);

    async processGeneratedAudioFile(audioFilePath) {

    async run(reconstructedcommandLine) {

            await this.runWithoutCatch(reconstructedcommandLine);

            this.cliConsole.error(error.message);

    async runWithoutCatch(reconstructedcommandLine) {

            this.cliConsole.debug(`Executing command line: ${reconstructedcommandLine}`);

        for (const chapter of this._script.chapters) {

            const chapterIndex = chapter.index;

            if (!this.chapterRange || this.chapterRange.has(chapterIndex)) {

                this.cliConsole.debug(`Entering chapter [${chapterIndex}] ${chapter.key}`);

                for (const section of chapter.sections) {

                    const sectionIndex = section.index;

                    if (!this.sectionRange || this.sectionRange.has(sectionIndex)) {

                        this.cliConsole.debug(`Entering section [${chapterIndex}-${sectionIndex}] ${section.key}`);

                        for (const paragraph of section.paragraphs) {

                            const paragraphIndex = paragraph.index;

                            // wait for user key press if needed

                            if (paragraphIndex === 1 && this.flags.interactive) {

                                const response = await (0, prompts_1.default)({

                                    initial: true,

                                    message: `Press ENTER to continue or CTRL-C to abort => [${chapterIndex}-${sectionIndex}] ${section.key}`,

                                    name: 'r',

                                    type: 'confirm',

                                if (response.r === undefined) { // CTRL-C

                                    return;

                            this.cliConsole.debug(`Entering paragraph [${chapterIndex}-${sectionIndex}-${paragraphIndex}] ${paragraph.key}`);

                            this.cliConsole.debug(`Processing: ${paragraph.text}`);

                            // generate SSML and its hash

                            await this.initialiseTtsServiceIfNeeded(); // initialise in first use

                            const ssml = await this.ttsService.generateSSML(paragraph);

                            const ssmlHash = this.hash(ssml, paragraph);

                            if (this.flags.ssml) {

                                this.cliConsole.info(`SSML generated with hash ${ssmlHash}:`);

                                this.cliConsole.info(ssml);

                            const generatedAudioFilePath = await this.determineAudioFilePath(ssmlHash, paragraph);

                            if (this.flags['dry-run']) {

                                this.cliConsole.debug('No action because of dry-run flag');

                                // check to see if the .mp3 file already exists

                                if (!this.flags.overwrite && fs.existsSync(generatedAudioFilePath)) {

                                    this.cliConsole.debug(`Re-using already existing audio file '${generatedAudioFilePath}' for ${chapterIndex}-${sectionIndex}-${paragraphIndex}`);

                                    // generate .mp3 file if needed

                                    await this.ttsService.generateAudio(ssml, {

                                        ...this.audioGenerationOptions,

                                        outputFilePath: generatedAudioFilePath,

                                    const audioDuration = await (0, audio_utils_1.getAudioFileDuration)(generatedAudioFilePath);

                                    this.cliConsole.debug(`Generated audio of ${audioDuration / 1000}s: ${generatedAudioFilePath}`);

                                // post-processing

                                const audioFilePath = await this.processGeneratedAudioFile(generatedAudioFilePath);

                                paragraph.audioFilePath = audioFilePath;

                                // play .mp3 file if needed

                                if (this.flags.play) {

                                    await (0, audio_utils_1.playMp3File)(audioFilePath);

                                    this.cliConsole.debug(`Finished playing: ${audioFilePath}`);

        this.cliConsole.debug(`Finished processing ${this.scriptFilePath}`);

exports.ScriptProcessor = ScriptProcessor;

  "description": "Generate narration with Text-To-Speech technology",

    "prepare": "shx rm -rf dist api-docs && tsc && es-check",

    "preversion": "generate-api-docs-and-update-readme && ./bin/run --update-readme.md && git add README.md"

    "@handy-common-utils/dev-dependencies": "^1.0.20",

    "typedoc-plugin-remove-references": "^0.0.5"

    "@handy-common-utils/oclif-utils": "^1.0.7",

    "@handy-common-utils/promise-utils": "^1.1.1",

    "microsoft-cognitiveservices-speech-sdk": "^1.18.1",

  "homepage": "https://github.com/james-hu/tts-narrator#readme",

    "url": "git+https://github.com/james-hu/tts-narrator.git"

    "url": "https://github.com/james-hu/tts-narrator/issues"

		@@ -97,3 +97,3 @@ "use strict";
		if (!fs.existsSync(audioFileFolder)) {
		fs.mkdirSync(audioFileFolder);
		fs.mkdirSync(audioFileFolder, { recursive: true });
		}
		@@ -189,5 +189,5 @@ const audioFilePath = path_1.default.join(audioFileFolder, `${ssmlHash}.mp3`);
		get script() {
		return this.script;
		return this._script;
		}
		}
		exports.ScriptProcessor = ScriptProcessor;

		{
		"name": "tts-narrator",
		"version": "1.0.13",
		"version": "1.0.14",
		"description": "Generate narration with Text-To-Speech technology",
		@@ -5,0 +5,0 @@ "main": "dist/types.js",

Improved metrics