Spaces:
Running
on
CPU Upgrade
Running
on
CPU Upgrade
| window.appVersion = "v3.0.3" | |
| const {Editor} = require("./javascript/editor.js") | |
| require("./javascript/textarea.js") | |
| const xVASpeech = require("./javascript/speech2speech.js") | |
| // Newly introduced in v3. I will slowly start moving global context variables into this, and update code throughout to reference this | |
| // instead of old variables such as window.games, window.currentModel, etc. | |
| window.appState = {} | |
| // Start the server | |
| if (window.PRODUCTION) { | |
| window.pythonProcess = spawn(`${path}/cpython_${window.userSettings.installation}/server.exe`, {stdio: "ignore"}) | |
| } | |
| let themeColour | |
| let secondaryThemeColour | |
| const oldCError = console.error | |
| console.error = (...rest) => { | |
| window.appLogger.log(`console.error: ${rest}`) | |
| oldCError(rest) | |
| } | |
| window.addEventListener("error", function (e) {window.appLogger.log(`error: ${e.error.stack}`)}) | |
| window.addEventListener('unhandledrejection', function (e) {window.appLogger.log(`unhandledrejection: ${e.stack}`)}) | |
| setTimeout(() => { | |
| window.electron = require("electron") | |
| }, 1000) | |
| window.games = {} | |
| window.models = {} | |
| window.sequenceEditor = new Editor() | |
| window.currentModel = undefined | |
| window.currentModelButton = undefined | |
| window.watchedModelsDirs = [] | |
| window.appLogger.log(`Settings: ${JSON.stringify(window.userSettings)}`) | |
| // Set up folders | |
| try {fs.mkdirSync(`${path}/models`)} catch (e) {/*Do nothing*/} | |
| try {fs.mkdirSync(`${path}/output`)} catch (e) {/*Do nothing*/} | |
| try {fs.mkdirSync(`${path}/assets`)} catch (e) {/*Do nothing*/} | |
| // Clean up temp files | |
| const clearOldTempFiles = () => { | |
| fs.readdir(`${__dirname.replace("/javascript", "")}/output`, (err, files) => { | |
| if (err) { | |
| window.appLogger.log(`Error cleaning up temp files: ${err}`) | |
| } | |
| if (files && files.length) { | |
| files.filter(f => f.startsWith("temp-")).forEach(file => { | |
| fs.unlink(`${__dirname.replace("/javascript", "")}/output/${file}`, err => err&&console.log(err)) | |
| }) | |
| } | |
| }) | |
| } | |
| clearOldTempFiles() | |
| let fileRenameCounter = 0 | |
| let fileChangeCounter = 0 | |
| window.isGenerating = false | |
| window.registerModel = (modelsPath, gameFolder, model, {gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) => { | |
| // Add game, if the game hasn't been added yet | |
| let audioPreviewPath | |
| try { | |
| audioPreviewPath = `${modelsPath}/${model.games.find(({gameId}) => gameId==gameFolder).voiceId}` | |
| } catch (e) {} | |
| if (!window.games.hasOwnProperty(gameId)) { | |
| const gameAsset = fs.readdirSync(`${path}/assets`).find(f => f==gameId+".json") | |
| if (gameAsset && gameAsset.length && gameAsset[0]) { | |
| const gameTheme = JSON.parse(fs.readFileSync(`${path}/assets/${gameAsset}`)) | |
| window.games[gameId] = { | |
| models: [], | |
| gameTheme, | |
| gameAsset | |
| } | |
| } else { | |
| window.appLogger.log(`Something not right with loading model: ${voiceId} . The asset file for its game (${gameId}) could not be found here: ${path}/assets. You need a ${gameId}.json file. Loading a generic theme for this voice's game/category.`) | |
| const dummyGameTheme = { | |
| "gameName": gameId, | |
| "assetFile": "other.jpg", | |
| "themeColourPrimary": "aaaaaa", | |
| "themeColourSecondary": null, | |
| "gameCode": "x", | |
| "nexusGamePageIDs": [] | |
| } | |
| const dummyGameAsset = "other.json" | |
| window.games[gameId] = { | |
| models: [], | |
| dummyGameTheme, | |
| dummyGameAsset | |
| } | |
| audioPreviewPath = `${modelsPath}/${model.games[0].voiceId}` | |
| } | |
| } | |
| // Catch duplicates, for when/if a model is registered for multiple games, but there's already the same model in that game, from another version | |
| // const existingDuplicates = [] | |
| // window.games[gameId].models.forEach((item,i) => { | |
| // if (item.voiceId==voiceId) { | |
| // existingDuplicates.push([item, i]) | |
| // } | |
| // }) | |
| // Check if a variant has already been added for this voice name, for this game | |
| let foundVariantIndex = undefined | |
| window.games[gameId].models.forEach((item,i) => { | |
| if (foundVariantIndex!=undefined) return | |
| if (item.voiceName.toLowerCase().trim()==voiceName.toLowerCase().trim()) { | |
| foundVariantIndex = i | |
| } | |
| }) | |
| // Add the initial model metadata, if no existing variant has been added (will happen most of the time) | |
| if (!foundVariantIndex) { | |
| const modelData = { | |
| gameId, | |
| modelsPath, | |
| voiceName, | |
| lang_capabilities: model.lang_capabilities, | |
| embOverABaseModel: model.embOverABaseModel, | |
| variants: [] | |
| } | |
| window.games[gameId].models.push(modelData) | |
| foundVariantIndex = window.games[gameId].models.length-1 | |
| } | |
| const variantData = { | |
| author: model.author, | |
| version: model.version, | |
| modelVersion: model.modelVersion, | |
| modelType: model.modelType, | |
| base_speaker_emb: model.modelType=="xVAPitch" ? model.games[0].base_speaker_emb : undefined, | |
| voiceId, | |
| audioPreviewPath, | |
| hifi: undefined, | |
| num_speakers: model.emb_size, | |
| emb_i, | |
| variantName: variant ? variant.replace("Default :", "Default:").replace("Default:", "").trim() : "Default", | |
| voiceDescription, | |
| lang: model.lang, | |
| gender, | |
| modelType: modelType||model.modelType, | |
| model, | |
| } | |
| const potentialHiFiPath = `${modelsPath}/${voiceId}.hg.pt` | |
| if (fs.existsSync(potentialHiFiPath)) { | |
| variantData.hifi = potentialHiFiPath | |
| } | |
| const isDefaultVariant = !variant || variant.toLowerCase().startsWith("default") | |
| if (isDefaultVariant) { | |
| // Place first in the list, if it's default | |
| window.games[gameId].models[foundVariantIndex].audioPreviewPath = audioPreviewPath | |
| window.games[gameId].models[foundVariantIndex].variants.splice(0,0,variantData) | |
| } else { | |
| window.games[gameId].models[foundVariantIndex].variants.push(variantData) | |
| } | |
| // // Using the detected duplicates, use only the latest version | |
| // if (existingDuplicates.length) { | |
| // if (existingDuplicates[0][0].modelVersion<model.modelVersion) { | |
| // window.games[gameId].models.splice(existingDuplicates[0][1], 1) | |
| // window.games[gameId].models.push(modelData) | |
| // } | |
| // } else { | |
| // window.games[gameId].models.push(modelData) | |
| // } | |
| } | |
| window.loadAllModels = (forceUpdate=false) => { | |
| return new Promise(resolve => { | |
| if (!forceUpdate && window.nexusState.installQueue.length) { | |
| return | |
| } | |
| let gameFolder | |
| let modelPathsKeys = Object.keys(window.userSettings).filter(key => key.includes("modelspath_")) | |
| window.games = {} | |
| // Do the current game first, and stop blocking the render process | |
| if (window.currentGame) { | |
| const currentGameFolder = window.userSettings[`modelspath_${window.currentGame.gameId}`] | |
| gameFolder = currentGameFolder | |
| try { | |
| const files = fs.readdirSync(modelsPath).filter(f => f.endsWith(".json")) | |
| files.forEach(fileName => { | |
| try { | |
| if (!models.hasOwnProperty(`${gameFolder}/${fileName}`)) { | |
| models[`${gameFolder}/${fileName}`] = null | |
| } | |
| const model = JSON.parse(fs.readFileSync(`${modelsPath}/${fileName}`, "utf8")) | |
| model.games.forEach(({gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) => { | |
| window.registerModel(currentGameFolder, gameFolder, model, {gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) | |
| }) | |
| } catch (e) { | |
| console.log(e) | |
| // window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME_WITH_FILENAME.replace("_1", gameFolder)} `+fileName) | |
| // window.appLogger.log(e) | |
| // window.appLogger.log(e.stack) | |
| } | |
| }) | |
| } catch (e) { | |
| window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME}: `+ gameFolder) | |
| window.appLogger.log(e) | |
| } | |
| resolve() // Continue the rest but asynchronously | |
| } | |
| modelPathsKeys.forEach(modelsPathKey => { | |
| const modelsPath = window.userSettings[modelsPathKey] | |
| try { | |
| const files = fs.readdirSync(modelsPath).filter(f => f.endsWith(".json")) | |
| if (!files.length) { | |
| return | |
| } | |
| files.forEach(fileName => { | |
| gameFolder = modelsPathKey.split("_")[1] | |
| try { | |
| if (!models.hasOwnProperty(`${gameFolder}/${fileName}`)) { | |
| models[`${gameFolder}/${fileName}`] = null | |
| } | |
| const model = JSON.parse(fs.readFileSync(`${modelsPath}/${fileName}`, "utf8")) | |
| model.games.forEach(({gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) => { | |
| window.registerModel(modelsPath, gameFolder, model, {gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) | |
| }) | |
| } catch (e) { | |
| console.log(e) | |
| setTimeout(() => { | |
| window.errorModal(`${fileName}<br><br>${e.stack}`) | |
| }, 1000) | |
| window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME_WITH_FILENAME.replace("_1", gameFolder)} `+fileName) | |
| window.appLogger.log(e) | |
| window.appLogger.log(e.stack) | |
| } | |
| }) | |
| } catch (e) { | |
| window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME}: `+ gameFolder) | |
| window.appLogger.log(e) | |
| } | |
| }) | |
| window.updateGameList(false) | |
| resolve() | |
| }) | |
| } | |
| // Change variant | |
| let oldVariantSelection = undefined // For reverting, if versioning checks fail | |
| variant_select.addEventListener("change", () => { | |
| const model = window.games[window.currentGame.gameId].models.find(model => model.voiceName== window.currentModel.voiceName) | |
| const variant = model.variants.find(variant => variant.variantName==variant_select.value) | |
| const appVersionOk = window.checkVersionRequirements(variant.version, appVersion) | |
| if (!appVersionOk) { | |
| window.errorModal(`${window.i18n.MODEL_REQUIRES_VERSION} v${variant.version}<br><br>${window.i18n.THIS_APP_VERSION}: ${window.appVersion}`) | |
| variant_select.value = oldVariantSelection | |
| return | |
| } | |
| generateVoiceButton.dataset.modelQuery = JSON.stringify({ | |
| outputs: parseInt(model.outputs), | |
| model: model.embOverABaseModel ? window.userSettings[`modelspath_${model.embOverABaseModel.split("/")[0]}`]+`/${model.embOverABaseModel.split("/")[1]}` : `${model.modelsPath}/${variant.voiceId}`, | |
| modelType: variant.modelType, | |
| version: variant.version, | |
| model_speakers: model.num_speakers, | |
| base_lang: model.lang || "en" | |
| }) | |
| oldVariantSelection = variant_select.value | |
| titleInfoVoiceID.innerHTML = variant.voiceId | |
| titleInfoGender.innerHTML = variant.gender || "?" | |
| titleInfoAppVersion.innerHTML = variant.version || "?" | |
| titleInfoModelVersion.innerHTML = variant.modelVersion || "?" | |
| titleInfoModelType.innerHTML = variant.modelType || "?" | |
| titleInfoLanguage.innerHTML = variant.lang || window.currentModel.games[0].lang || "en" | |
| titleInfoAuthor.innerHTML = variant.author || "?" | |
| generateVoiceButton.click() | |
| }) | |
| // Change game | |
| window.changeGame = (meta) => { | |
| titleInfo.style.display = "none" | |
| window.currentGame = meta | |
| themeColour = meta.themeColourPrimary | |
| secondaryThemeColour = meta.themeColourSecondary | |
| let titleID = meta.gameCode | |
| generateVoiceButton.disabled = true | |
| generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE | |
| selectedGameDisplay.innerHTML = meta.gameName | |
| // Change the app title | |
| titleName.innerHTML = window.i18n.SELECT_VOICE_TYPE | |
| if (window.games[window.currentGame.gameId] == undefined) { | |
| titleName.innerHTML = `${window.i18n.NO_MODELS_IN}: ${window.userSettings[`modelspath_${window.currentGame.gameId}`]}` | |
| } | |
| const gameFolder = meta.gameId | |
| const gameName = meta.gameName | |
| setting_models_path_container.style.display = "flex" | |
| setting_out_path_container.style.display = "flex" | |
| setting_models_path_label.innerHTML = `<i style="display:inline">${gameName}</i><span>${window.i18n.SETTINGS_MODELS_PATH}</span>` | |
| setting_models_path_input.value = window.userSettings[`modelspath_${gameFolder}`] | |
| setting_out_path_label.innerHTML = `<i style="display:inline">${gameName}</i> ${window.i18n.SETTINGS_OUTPUT_PATH}` | |
| setting_out_path_input.value = window.userSettings[`outpath_${gameFolder}`] | |
| window.setTheme(window.currentGame) | |
| try { | |
| window.displayAllModels() | |
| } catch (e) {console.log(e)} | |
| try {fs.mkdirSync(`${path}/output/${meta.gameId}`)} catch (e) {/*Do nothing*/} | |
| localStorage.setItem("lastGame", JSON.stringify(meta)) | |
| // Populate models | |
| voiceTypeContainer.innerHTML = "" | |
| voiceSamples.innerHTML = "" | |
| const buttons = [] | |
| const totalNumVoices = (window.games[meta.gameId] ? window.games[meta.gameId].models : []).reduce((p,c)=>p+c.variants.length, 0) | |
| voiceSearchInput.placeholder = window.i18n.SEARCH_N_VOICES.replace("_", window.games[meta.gameId] ? totalNumVoices : "0") | |
| voiceSearchInput.value = "" | |
| if (!window.games[meta.gameId]) { | |
| return | |
| } | |
| (window.games[meta.gameId] ? window.games[meta.gameId].models : []).forEach(({modelsPath, audioPreviewPath, gameId, variants, voiceName, embOverABaseModel}) => { | |
| const {voiceId, voiceDescription, hifi, model} = variants[0] | |
| const modelVersion = variants[0].version | |
| const button = createElem("div.voiceType", voiceName) | |
| button.style.background = `#${themeColour}` | |
| if (embOverABaseModel) { | |
| button.style.fontStyle = "italic" | |
| } | |
| if (window.userSettings.do_model_version_highlight && parseFloat(modelVersion)<window.userSettings.model_version_highlight) { | |
| button.style.border = `2px solid #${themeColour}` | |
| button.style.padding = "0" | |
| button.style.background = "none" | |
| } | |
| button.dataset.modelId = voiceId | |
| if (secondaryThemeColour) { | |
| button.style.color = `#${secondaryThemeColour}` | |
| button.style.textShadow = `none` | |
| } | |
| // Quick voice set preview, if there is a preview file | |
| button.addEventListener("contextmenu", () => { | |
| window.appLogger.log(`${audioPreviewPath}.wav`) | |
| const audioPreview = createElem("audio", {autoplay: false}, createElem("source", { | |
| src: `${audioPreviewPath}.wav` | |
| })) | |
| audioPreview.style.height = "25px" | |
| audioPreview.setSinkId(window.userSettings.base_speaker) | |
| }) | |
| if (embOverABaseModel) { | |
| const gameOfBaseModel = embOverABaseModel.split("/")[0] | |
| if (gameOfBaseModel=="<base>") { | |
| // For included base v3 models | |
| modelsPath = `${window.path}/python/xvapitch/${embOverABaseModel.split("/")[1]}` | |
| } else { | |
| // For any other model | |
| const gameModelsPath = `${window.userSettings[`outpath_${gameOfBaseModel}`]}` | |
| modelsPath = `${gameModelsPath}/${embOverABaseModel.split("/")[1]}` | |
| } | |
| } | |
| button.addEventListener("click", event => window.selectVoice(event, variants, hifi, gameId, voiceId, model, button, audioPreviewPath, modelsPath, meta, embOverABaseModel)) | |
| buttons.push(button) | |
| }) | |
| buttons.sort((a,b) => a.innerHTML.toLowerCase()<b.innerHTML.toLowerCase()?-1:1) | |
| .forEach(button => voiceTypeContainer.appendChild(button)) | |
| } | |
| window.selectVoice = (event, variants, hifi, gameId, voiceId, model, button, audioPreviewPath, modelsPath, meta, embOverABaseModel) => { | |
| // Just for easier packaging of the voice models for publishing - yes, lazy | |
| if (event.ctrlKey && event.shiftKey) { | |
| window.packageVoice(event.altKey, variants, {modelsPath, gameId}) | |
| } | |
| variant_select.innerHTML = "" | |
| oldVariantSelection = undefined | |
| if (variants.length==1) { | |
| variantElements.style.display = "none" | |
| } else { | |
| variantElements.style.display = "flex" | |
| variants.forEach(variant => { | |
| const option = createElem("option", {value: variant.variantName}) | |
| option.innerHTML = variant.variantName | |
| variant_select.appendChild(option) | |
| if (!oldVariantSelection) { | |
| oldVariantSelection = variant.variantName | |
| } | |
| }) | |
| } | |
| if (hifi) { | |
| // Remove the bespoke hifi option if there was one already there | |
| Array.from(vocoder_select.children).forEach(opt => { | |
| if (opt.innerHTML=="Bespoke HiFi GAN") { | |
| vocoder_select.removeChild(opt) | |
| } | |
| }) | |
| bespoke_hifi_bolt.style.opacity = 1 | |
| const option = createElem("option", "Bespoke HiFi GAN") | |
| option.value = `${gameId}/${voiceId}.hg.pt` | |
| vocoder_select.appendChild(option) | |
| } else { | |
| bespoke_hifi_bolt.style.opacity = 0 | |
| // Set the vocoder select to quick-and-dirty if bespoke hifi-gan was selected | |
| if (vocoder_select.value.includes(".hg.")) { | |
| vocoder_select.value = "qnd" | |
| window.changeVocoder("qnd") | |
| } | |
| // Remove the bespoke hifi option if there was one already there | |
| Array.from(vocoder_select.children).forEach(opt => { | |
| if (opt.innerHTML=="Bespoke HiFi GAN") { | |
| vocoder_select.removeChild(opt) | |
| } | |
| }) | |
| } | |
| window.currentModel = model | |
| window.currentModel.voiceId = voiceId | |
| window.currentModel.voiceName = button.innerHTML | |
| window.currentModel.hifi = hifi | |
| window.currentModel.audioPreviewPath = audioPreviewPath | |
| window.currentModelButton = button | |
| generateVoiceButton.dataset.modelQuery = null | |
| // The model is already loaded. Don't re-load it. | |
| if (generateVoiceButton.dataset.modelIDLoaded == voiceId) { | |
| generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE | |
| generateVoiceButton.dataset.modelQuery = "null" | |
| } else { | |
| generateVoiceButton.innerHTML = window.i18n.LOAD_MODEL | |
| generateVoiceButton.dataset.modelQuery = JSON.stringify({ | |
| outputs: parseInt(model.outputs), | |
| model: model.embOverABaseModel ? window.userSettings[`modelspath_${model.embOverABaseModel.split("/")[0]}`]+`/${model.embOverABaseModel.split("/")[1]}` : `${modelsPath}/${model.voiceId}`, | |
| modelType: model.modelType, | |
| version: model.version, | |
| model_speakers: model.emb_size, | |
| cmudict: model.cmudict, | |
| base_lang: model.lang || "en" | |
| }) | |
| generateVoiceButton.dataset.modelIDToLoad = voiceId | |
| } | |
| generateVoiceButton.disabled = false | |
| titleName.innerHTML = button.innerHTML | |
| titleInfo.style.display = "flex" | |
| titleInfoName.innerHTML = window.currentModel.voiceName | |
| titleInfoVoiceID.innerHTML = voiceId | |
| titleInfoGender.innerHTML = window.currentModel.games[0].gender || "?" | |
| titleInfoAppVersion.innerHTML = window.currentModel.version || "?" | |
| titleInfoModelVersion.innerHTML = window.currentModel.modelVersion || "?" | |
| titleInfoModelType.innerHTML = window.currentModel.modelType || "?" | |
| titleInfoLanguage.innerHTML = window.currentModel.lang || window.currentModel.games[0].lang || "en" | |
| titleInfoAuthor.innerHTML = window.currentModel.author || "?" | |
| titleInfoLicense.innerHTML = window.currentModel.license || window.i18n.UNKNOWN | |
| title.dataset.modelId = voiceId | |
| keepSampleButton.style.display = "none" | |
| samplePlayPause.style.display = "none" | |
| // Voice samples | |
| voiceSamples.innerHTML = "" | |
| window.initMainPagePagination(`${window.userSettings[`outpath_${meta.gameId}`]}/${button.dataset.modelId}`) | |
| window.refreshRecordsList() | |
| } | |
| titleInfo.addEventListener("click", () => titleDetails.style.display = titleDetails.style.display=="none" ? "block" : "none") | |
| window.addEventListener("click", event => { | |
| if (event.target!=titleInfo && event.target!=titleDetails && event.target.parentNode && event.target.parentNode!=titleDetails && event.target.parentNode.parentNode!=titleDetails) { | |
| titleDetails.style.display = "none" | |
| } | |
| }) | |
| titleDetails.style.display = "none" | |
| window.loadModel = () => { | |
| return new Promise(resolve => { | |
| if (window.batch_state.state) { | |
| window.errorModal(window.i18n.BATCH_ERR_IN_PROGRESS) | |
| return | |
| } | |
| const body = JSON.parse(generateVoiceButton.dataset.modelQuery) | |
| const appVersionOk = window.checkVersionRequirements(body.version, appVersion) | |
| if (!appVersionOk) { | |
| window.errorModal(`${window.i18n.MODEL_REQUIRES_VERSION} v${body.version}<br><br>${window.i18n.THIS_APP_VERSION}: ${window.appVersion}`) | |
| return | |
| } | |
| window.appLogger.log(`${window.i18n.LOADING_VOICE}: ${JSON.parse(generateVoiceButton.dataset.modelQuery).model}`) | |
| window.batch_state.lastModel = JSON.parse(generateVoiceButton.dataset.modelQuery).model.split("/").reverse()[0] | |
| body["pluginsContext"] = JSON.stringify(window.pluginsContext) | |
| spinnerModal(`${window.i18n.LOADING_VOICE}`) | |
| doFetch(`http://localhost:8008/loadModel`, { | |
| method: "Post", | |
| body: JSON.stringify(body) | |
| }).then(r=>r.text()).then(res => { | |
| window.currentModel.loaded = true | |
| generateVoiceButton.dataset.modelQuery = null | |
| generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE | |
| generateVoiceButton.dataset.modelIDLoaded = generateVoiceButton.dataset.modelIDToLoad | |
| // Set the editor pitch/energy dropdowns to pitch, and freeze them, if energy is not supported by the model | |
| window.appState.currentModelEmbeddings = {} | |
| if (window.currentModel.modelType.toLowerCase()=="xvapitch" && !window.currentModel.isBaseModel) { | |
| vocoder_options_container.style.display = "none" | |
| base_lang_select.disabled = false | |
| style_emb_select.disabled = false | |
| window.loadStyleEmbsForVoice(window.currentModel) | |
| mic_SVG.children[0].style.fill = "white" | |
| base_lang_select.value = window.currentModel.lang | |
| } else { | |
| vocoder_options_container.style.display = "inline-block" | |
| base_lang_select.disabled = true | |
| style_emb_select.disabled = true | |
| mic_SVG.children[0].style.fill = "grey" | |
| } | |
| if (window.currentModel.modelType.toLowerCase()=="fastpitch") { | |
| seq_edit_view_select.value = "pitch" | |
| seq_edit_edit_select.value = "pitch" | |
| seq_edit_view_select.disabled = true | |
| seq_edit_edit_select.disabled = true | |
| } else { | |
| seq_edit_view_select.value = "pitch_energy" | |
| seq_edit_view_select.disabled = false | |
| seq_edit_edit_select.disabled = false | |
| } | |
| window.populateLanguagesDropdownsFromModel(base_lang_select, window.currentModel) | |
| base_lang_select.value = window.currentModel.lang | |
| if (window.userSettings.defaultToHiFi && window.currentModel.hifi) { | |
| vocoder_select.value = Array.from(vocoder_select.children).find(opt => opt.innerHTML=="Bespoke HiFi GAN").value | |
| window.changeVocoder(vocoder_select.value).then(() => dialogueInput.focus()) | |
| } else if (window.userSettings.vocoder.includes(".hg.pt")) { | |
| window.changeVocoder("qnd").then(() => dialogueInput.focus()) | |
| } else { | |
| closeModal(null, [workbenchContainer]).then(() => dialogueInput.focus()) | |
| } | |
| resolve() | |
| }).catch(e => { | |
| console.log(e) | |
| if (e.code =="ENOENT") { | |
| closeModal(null, [modalContainer, workbenchContainer]).then(() => { | |
| window.errorModal(window.i18n.ERR_SERVER) | |
| resolve() | |
| }) | |
| } | |
| }) | |
| }) | |
| } | |
| // Return true/false for if the prompt is the same - BUT: allow phoneme swaps | |
| window.checkIfPromptIsTheSame = (sequence) => { | |
| // False if there was no previous prompt | |
| if (!window.sequenceEditor.historyState.length) { | |
| return false | |
| } | |
| const lastPrompt = window.sequenceEditor.historyState.at(-1) | |
| // False if they're different lengths | |
| if (sequence.length != lastPrompt.length) { | |
| return false | |
| } | |
| // Split into words (and phonemes) | |
| const currentParts = sequence.split(" ") | |
| const lastParts = lastPrompt.split(" ") | |
| for (let si=0; si<currentParts.length; si++) { | |
| // False if a word is different, but not if it's an ARPAbet symbol | |
| const cleaned = currentParts[si].replace(/[^a-zA-Z]/g, "") | |
| if (currentParts[si]!=lastParts[si] && !window.ARPAbetSymbols.includes(cleaned)) { | |
| return false | |
| } | |
| } | |
| return true | |
| } | |
| window.synthesizeSample = () => { | |
| const game = window.currentGame.gameId | |
| if (window.isGenerating) { | |
| return | |
| } | |
| if (!window.speech2speechState.s2s_running) { | |
| clearOldTempFiles() | |
| } | |
| let sequence = dialogueInput.value.replace("…", "...").replace("’", "'") | |
| if (window.userSettings.spacePadding && !window.sequenceEditor.isEditingFromFile) { // Pad start and end of the input sequence with spaces | |
| sequence = " "+sequence.trim()+" " | |
| } | |
| window.sequenceEditor.isEditingFromFile = false | |
| if (sequence.length==0) { | |
| return | |
| } | |
| window.isGenerating = true | |
| window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["generate-voice"]["pre"], event="pre generate-voice") | |
| if (window.wavesurfer) { | |
| try { | |
| window.wavesurfer.stop() | |
| } catch (e) { | |
| console.log(e) | |
| } | |
| wavesurferContainer.style.opacity = 0 | |
| } | |
| toggleSpinnerButtons() | |
| const voiceType = title.dataset.modelId | |
| const outputFileName = dialogueInput.value.slice(0, 260).replace(/\n/g, " ").replace(/[\/\\:\*?<>"|]*/g, "").replace(/^[\.\s]+/, "") | |
| try {fs.unlinkSync(localStorage.getItem("tempFileLocation"))} catch (e) {/*Do nothing*/} | |
| // For some reason, the samplePlay audio element does not update the source when the file name is the same | |
| const tempFileNum = `${Math.random().toString().split(".")[1]}` | |
| let tempFileLocation = `${path}/output/temp-${tempFileNum}.wav` | |
| let pitch = [] | |
| let duration = [] | |
| let energy = [] | |
| let emAngry = [] | |
| let emHappy = [] | |
| let emSad = [] | |
| let emSurprise = [] | |
| let editorStyles = {} | |
| let isFreshRegen = true | |
| let old_sequence = undefined | |
| if (editorContainer.innerHTML && editorContainer.innerHTML.length && generateVoiceButton.dataset.modelIDLoaded==window.sequenceEditor.currentVoice) { | |
| if (window.sequenceEditor.audioInput || window.sequenceEditor.sequence && sequence!=window.sequenceEditor.inputSequence) { | |
| old_sequence = window.sequenceEditor.inputSequence | |
| } | |
| } | |
| // Don't use the old_sequence if running speech-to-speech | |
| if (window.speech2speechState.s2s_running) { | |
| old_sequence = undefined | |
| window.speech2speechState.s2s_running = false | |
| } | |
| // Check if editing an existing line (otherwise it's a fresh new line) | |
| const languageHasChanged = window.sequenceEditor.base_lang && window.sequenceEditor.base_lang != base_lang_select.value | |
| const promptHasChanged = !window.checkIfPromptIsTheSame(sequence) | |
| if (!promptHasChanged && !languageHasChanged && !window.arpabetMenuState.hasChangedARPAbet && !window.styleEmbsMenuState.hasChangedEmb && | |
| (speech2speechState.s2s_autogenerate || (editorContainer.innerHTML && editorContainer.innerHTML.length && (window.userSettings.keepEditorOnVoiceChange || generateVoiceButton.dataset.modelIDLoaded==window.sequenceEditor.currentVoice)))) { | |
| speech2speechState.s2s_autogenerate = false | |
| pitch = window.sequenceEditor.pitchNew.map(v=> v==undefined?0:v) | |
| duration = window.sequenceEditor.dursNew.map(v => v*pace_slid.value).map(v=> v==undefined?0:v) | |
| energy = window.sequenceEditor.energyNew ? window.sequenceEditor.energyNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : [] | |
| if (window.currentModel.modelType=="xVAPitch") { | |
| emAngry = window.sequenceEditor.emAngryNew ? window.sequenceEditor.emAngryNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : [] | |
| emHappy = window.sequenceEditor.emHappyNew ? window.sequenceEditor.emHappyNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : [] | |
| emSad = window.sequenceEditor.emSadNew ? window.sequenceEditor.emSadNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : [] | |
| emSurprise = window.sequenceEditor.emSurpriseNew ? window.sequenceEditor.emSurpriseNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : [] | |
| if (window.sequenceEditor.registeredStyleKeys) { | |
| window.sequenceEditor.registeredStyleKeys.forEach(styleKey => { | |
| editorStyles[styleKey] = { | |
| embedding: window.appState.currentModelEmbeddings[styleKey][1], | |
| sliders: window.sequenceEditor.styleValuesNew[styleKey].map(v => v==undefined?0:v).filter(v => !isNaN(v))// : [] | |
| } | |
| }) | |
| } | |
| } | |
| isFreshRegen = false | |
| } | |
| window.arpabetMenuState.hasChangedARPAbet = false | |
| window.styleEmbsMenuState.hasChangedEmb = false | |
| window.sequenceEditor.currentVoice = generateVoiceButton.dataset.modelIDLoaded | |
| const speaker_i = window.currentModel.games[0].emb_i | |
| const pace = (window.userSettings.keepPaceOnNew && isFreshRegen)?pace_slid.value:1 | |
| window.appLogger.log(`${window.i18n.SYNTHESIZING}: ${sequence}`) | |
| doFetch(`http://localhost:8008/synthesize`, { | |
| method: "Post", | |
| body: JSON.stringify({ | |
| sequence, pitch, duration, energy, emAngry, emHappy, emSad, emSurprise, editorStyles, speaker_i, pace, | |
| base_lang: base_lang_select.value, | |
| base_emb: style_emb_select.value||"", | |
| modelType: window.currentModel.modelType, | |
| old_sequence, // For partial re-generation | |
| device: window.userSettings.installation=="cpu"?"cpu":(window.userSettings.useGPU?"cuda:0":"cpu"), | |
| // device: window.userSettings.useGPU?"gpu":"cpu", // Switch to this once DirectML is installed | |
| useSR: useSRCkbx.checked, | |
| useCleanup: useCleanupCkbx.checked, | |
| outfile: tempFileLocation, | |
| pluginsContext: JSON.stringify(window.pluginsContext), | |
| vocoder: window.currentModel.modelType=="xVAPitch" ? "n/a" : window.userSettings.vocoder, | |
| waveglowPath: vocoder_select.value=="256_waveglow" ? window.userSettings.waveglow_path : window.userSettings.bigwaveglow_path | |
| }) | |
| }).then(r=>r.text()).then(res => { | |
| window.isGenerating = false | |
| if (res=="ENOENT" || res.startsWith("ERR:")) { | |
| console.log(res) | |
| if (res.startsWith("ERR:")) { | |
| if (res.includes("ARPABET_NOT_IN_LIST")) { | |
| const symbolNotInList = res.split(":").reverse()[0] | |
| window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${window.i18n.ERR_ARPABET_NOT_EXIST.replace("_1", symbolNotInList)}`) | |
| } else { | |
| window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${res.replace("ERR:","").replaceAll(/\n/g, "<br>")}`) | |
| } | |
| } else { | |
| window.appLogger.log(res) | |
| window.errorModal(`${window.i18n.BATCH_MODEL_NOT_FOUND}.${vocoder_select.value.includes("waveglow")?" "+window.i18n.BATCH_DOWNLOAD_WAVEGLOW:""}`) | |
| } | |
| toggleSpinnerButtons() | |
| return | |
| } | |
| dialogueInput.focus() | |
| window.sequenceEditor.historyState.push(sequence) | |
| if (window.userSettings.clear_text_after_synth) { | |
| dialogueInput.value = "" | |
| } | |
| res = res.split("\n") | |
| let pitchData = res[0] | |
| let durationsData = res[1] | |
| let energyData = res[2] | |
| let em_angryData = res[3] | |
| let em_happyData = res[4] | |
| let em_sadData = res[5] | |
| let em_surpriseData = res[6] | |
| const editorStyles = res[7]&&res[7].length ? JSON.parse(res[7]) : undefined | |
| let cleanedSequence = res[8].split("|").map(c=>c.replaceAll("{", "").replaceAll("}", "").replace(/\s/g, "_")) | |
| const start_index = res[9] | |
| const end_index = res[10] | |
| pitchData = pitchData.split(",").map(v => parseFloat(v)) | |
| // For use in adjusting editor range | |
| const maxPitchVal = pitchData.reduce((p,c)=>Math.max(p, Math.abs(c)), 0) | |
| if (maxPitchVal>window.sequenceEditor.default_pitchSliderRange) { | |
| window.sequenceEditor.pitchSliderRange = maxPitchVal | |
| } else { | |
| window.sequenceEditor.pitchSliderRange = window.sequenceEditor.default_pitchSliderRange | |
| } | |
| em_angryData = em_angryData.length ? em_angryData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : [] | |
| em_happyData = em_happyData.length ? em_happyData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : [] | |
| em_sadData = em_sadData.length ? em_sadData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : [] | |
| em_surpriseData = em_surpriseData.length ? em_surpriseData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : [] | |
| if (energyData.length) { | |
| energyData = energyData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) | |
| // For use in adjusting editor range | |
| const maxEnergyVal = energyData.reduce((p,c)=>Math.max(p, c), 0) | |
| const minEnergyVal = energyData.reduce((p,c)=>Math.min(p, c), 100) | |
| if (minEnergyVal<window.sequenceEditor.default_MIN_ENERGY) { | |
| window.sequenceEditor.MIN_ENERGY = minEnergyVal | |
| } else { | |
| window.sequenceEditor.MIN_ENERGY = window.sequenceEditor.default_MIN_ENERGY | |
| } | |
| if (maxEnergyVal>window.sequenceEditor.default_MAX_ENERGY) { | |
| window.sequenceEditor.MAX_ENERGY = maxEnergyVal | |
| } else { | |
| window.sequenceEditor.MAX_ENERGY = window.sequenceEditor.default_MAX_ENERGY | |
| } | |
| } else { | |
| energyData = [] | |
| } | |
| durationsData = durationsData.split(",").map(v => isFreshRegen ? parseFloat(v) : parseFloat(v)/pace_slid.value) | |
| const doTheRest = () => { | |
| window.sequenceEditor.base_lang = base_lang_select.value | |
| window.sequenceEditor.inputSequence = sequence | |
| window.sequenceEditor.sequence = cleanedSequence | |
| if (pitch.length==0 || isFreshRegen) { | |
| window.sequenceEditor.resetPitch = pitchData | |
| window.sequenceEditor.resetDurs = durationsData | |
| window.sequenceEditor.resetEnergy = energyData | |
| window.sequenceEditor.resetEmAngry = em_angryData | |
| window.sequenceEditor.resetEmHappy = em_happyData | |
| window.sequenceEditor.resetEmSad = em_sadData | |
| window.sequenceEditor.resetEmSurprise = em_surpriseData | |
| } | |
| window.sequenceEditor.letters = cleanedSequence | |
| window.sequenceEditor.pitchNew = pitchData.map(p=>p) | |
| window.sequenceEditor.dursNew = durationsData.map(v=>v) | |
| window.sequenceEditor.energyNew = energyData.map(v=>v) | |
| if (window.currentModel.modelType=="xVAPitch") { | |
| window.sequenceEditor.emAngryNew = em_angryData.map(v=>v) | |
| window.sequenceEditor.emHappyNew = em_happyData.map(v=>v) | |
| window.sequenceEditor.emSadNew = em_sadData.map(v=>v) | |
| window.sequenceEditor.emSurpriseNew = em_surpriseData.map(v=>v) | |
| window.sequenceEditor.loadStylesData(editorStyles) | |
| } | |
| window.sequenceEditor.init() | |
| const pitchRange = window.userSettings.pitchrangeoverride ? window.userSettings.pitchrangeoverride : window.sequenceEditor.pitchSliderRange | |
| window.sequenceEditor.update(window.currentModel.modelType, pitchRange) | |
| window.sequenceEditor.sliderBoxes.forEach((box, i) => {box.setValueFromValue(window.sequenceEditor.dursNew[i])}) | |
| window.sequenceEditor.autoInferTimer = null | |
| window.sequenceEditor.hasChanged = false | |
| toggleSpinnerButtons() | |
| if (keepSampleButton.dataset.newFileLocation && keepSampleButton.dataset.newFileLocation.startsWith("BATCH_EDIT")) { | |
| console.log("_debug_") | |
| } else { | |
| if (window.userSettings[`outpath_${game}`]) { | |
| keepSampleButton.dataset.newFileLocation = `${window.userSettings[`outpath_${game}`]}/${voiceType}/${outputFileName}.wav` | |
| } else { | |
| keepSampleButton.dataset.newFileLocation = `${__dirname.replace(/\\/g,"/")}/output/${voiceType}/${outputFileName}.wav` | |
| } | |
| } | |
| keepSampleButton.disabled = false | |
| window.tempFileLocation = tempFileLocation | |
| // Wavesurfer | |
| if (!window.wavesurfer) { | |
| window.initWaveSurfer(`${__dirname.replace("/javascript", "")}/output/${tempFileLocation.split("/").reverse()[0]}`) | |
| } else { | |
| window.wavesurfer.load(`${__dirname.replace("/javascript", "")}/output/${tempFileLocation.split("/").reverse()[0]}`) | |
| } | |
| window.wavesurfer.on("ready", () => { | |
| wavesurferContainer.style.opacity = 1 | |
| if (window.userSettings.autoPlayGen) { | |
| if (window.userSettings.playChangedAudio) { | |
| const playbackStartEnd = window.sequenceEditor.getChangedTimeStamps(start_index, end_index, window.wavesurfer.getDuration()) | |
| if (playbackStartEnd) { | |
| wavesurfer.play(playbackStartEnd[0], playbackStartEnd[1]) | |
| } else { | |
| wavesurfer.play() | |
| } | |
| } else { | |
| wavesurfer.play() | |
| } | |
| window.sequenceEditor.adjustedLetters = new Set() | |
| samplePlayPause.innerHTML = window.i18n.PAUSE | |
| } | |
| }) | |
| // Persistance across sessions | |
| localStorage.setItem("tempFileLocation", tempFileLocation) | |
| } | |
| if (window.userSettings.audio.ffmpeg) { | |
| const options = { | |
| hz: window.userSettings.audio.hz, | |
| padStart: window.userSettings.audio.padStart, | |
| padEnd: window.userSettings.audio.padEnd, | |
| bit_depth: window.userSettings.audio.bitdepth, | |
| amplitude: window.userSettings.audio.amplitude, | |
| pitchMult: window.userSettings.audio.pitchMult, | |
| tempo: window.userSettings.audio.tempo, | |
| deessing: window.userSettings.audio.deessing, | |
| nr: window.userSettings.audio.nr, | |
| nf: window.userSettings.audio.nf, | |
| useNR: window.userSettings.audio.useNR, | |
| useSR: useSRCkbx.checked, | |
| useCleanup: useCleanupCkbx.checked, | |
| } | |
| const extraInfo = { | |
| game: window.currentGame.gameId, | |
| voiceId: window.currentModel.voiceId, | |
| voiceName: window.currentModel.voiceName, | |
| inputSequence: sequence, | |
| letters: cleanedSequence, | |
| pitch: pitchData.map(p=>p), | |
| energy: energyData.map(p=>p), | |
| em_angry: em_angryData.map(p=>p), | |
| em_happy: em_happyData.map(p=>p), | |
| em_sad: em_sadData.map(p=>p), | |
| em_surprise: em_surpriseData.map(p=>p), | |
| durations: durationsData.map(v=>v) | |
| } | |
| doFetch(`http://localhost:8008/outputAudio`, { | |
| method: "Post", | |
| body: JSON.stringify({ | |
| input_path: tempFileLocation, | |
| output_path: tempFileLocation.replace(".wav", `_ffmpeg.${window.userSettings.audio.format}`), | |
| pluginsContext: JSON.stringify(window.pluginsContext), | |
| extraInfo: JSON.stringify(extraInfo), | |
| isBatchMode: false, | |
| options: JSON.stringify(options) | |
| }) | |
| }).then(r=>r.text()).then(res => { | |
| if (res.length && res!="-") { | |
| console.log("res", res) | |
| window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${res}`).then(() => toggleSpinnerButtons()) | |
| } else { | |
| tempFileLocation = tempFileLocation.replace(".wav", `_ffmpeg.${window.userSettings.audio.format}`) | |
| doTheRest() | |
| } | |
| }).catch(res => { | |
| console.log(res) | |
| window.appLogger.log(`outputAudio error: ${res}`) | |
| // closeModal().then(() => { | |
| window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${res}`) | |
| // }) | |
| }) | |
| } else { | |
| doTheRest() | |
| } | |
| }).catch(res => { | |
| window.isGenerating = false | |
| console.log(res) | |
| window.appLogger.log(res) | |
| window.errorModal(window.i18n.SOMETHING_WENT_WRONG) | |
| toggleSpinnerButtons() | |
| }) | |
| } | |
| generateVoiceButton.addEventListener("click", () => { | |
| try {fs.mkdirSync(window.userSettings[`outpath_${game}`])} catch (e) {/*Do nothing*/} | |
| try {fs.mkdirSync(`${window.userSettings[`outpath_${game}`]}/${voiceId}`)} catch (e) {/*Do nothing*/} | |
| if (generateVoiceButton.dataset.modelQuery && generateVoiceButton.dataset.modelQuery!="null") { | |
| window.loadModel() | |
| } else { | |
| window.synthesizeSample() | |
| } | |
| }) | |
| window.saveFile = (from, to, skipUIRecord=false) => { | |
| to = to.split("%20").join(" ") | |
| to = to.replace(".wav", `.${window.userSettings.audio.format}`) | |
| // Make the containing folder if it does not already exist | |
| let containerFolderPath = to.split("/") | |
| containerFolderPath = containerFolderPath.slice(0,containerFolderPath.length-1).join("/") | |
| try {fs.mkdirSync(containerFolderPath)} catch (e) {/*Do nothing*/} | |
| // For plugins | |
| const pluginData = { | |
| game: window.currentGame.gameId, | |
| voiceId: window.currentModel.voiceId, | |
| voiceName: window.currentModel.voiceName, | |
| inputSequence: window.sequenceEditor.inputSequence, | |
| letters: window.sequenceEditor.letters, | |
| pitch: window.sequenceEditor.pitchNew, | |
| durations: window.sequenceEditor.dursNew, | |
| vocoder: vocoder_select.value, | |
| from, to | |
| } | |
| const options = { | |
| hz: window.userSettings.audio.hz, | |
| padStart: window.userSettings.audio.padStart, | |
| padEnd: window.userSettings.audio.padEnd, | |
| bit_depth: window.userSettings.audio.bitdepth, | |
| amplitude: window.userSettings.audio.amplitude, | |
| pitchMult: window.userSettings.audio.pitchMult, | |
| tempo: window.userSettings.audio.tempo, | |
| deessing: window.userSettings.audio.deessing, | |
| nr: window.userSettings.audio.nr, | |
| nf: window.userSettings.audio.nf, | |
| useNR: window.userSettings.audio.useNR, | |
| useSR: useSRCkbx.checked | |
| } | |
| pluginData.audioOptions = options | |
| window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["keep-sample"]["pre"], event="pre keep-sample", pluginData) | |
| const jsonDataOut = { | |
| modelType: window.currentModel.modelType, | |
| modelVersion: window.currentModel.modelVersion, | |
| version: window.currentModel.version, | |
| inputSequence: dialogueInput.value.trim(), | |
| pacing: parseFloat(pace_slid.value), | |
| letters: window.sequenceEditor.letters, | |
| currentVoice: window.sequenceEditor.currentVoice, | |
| resetEnergy: window.sequenceEditor.resetEnergy, | |
| resetPitch: window.sequenceEditor.resetPitch, | |
| resetDurs: window.sequenceEditor.resetDurs, | |
| resetEmAngry: window.sequenceEditor.resetEmAngry, | |
| resetEmHappy: window.sequenceEditor.resetEmHappy, | |
| resetEmSad: window.sequenceEditor.resetEmSad, | |
| resetEmSurprise: window.sequenceEditor.resetEmSurprise, | |
| styleValuesReset: window.sequenceEditor.styleValuesReset, | |
| ampFlatCounter: window.sequenceEditor.ampFlatCounter, | |
| inputSequence: window.sequenceEditor.inputSequence, | |
| sequence: window.sequenceEditor.sequence, | |
| pitchNew: window.sequenceEditor.pitchNew, | |
| energyNew: window.sequenceEditor.energyNew, | |
| dursNew: window.sequenceEditor.dursNew, | |
| emAngryNew: window.sequenceEditor.emAngryNew, | |
| emHappyNew: window.sequenceEditor.emHappyNew, | |
| emSadNew: window.sequenceEditor.emSadNew, | |
| emSurpriseNew: window.sequenceEditor.emSurpriseNew, | |
| styleValuesNew: window.sequenceEditor.styleValuesNew, | |
| } | |
| let outputFileName = to.split("/").reverse()[0].split(".").reverse().slice(1, 1000) | |
| const toExt = to.split(".").reverse()[0] | |
| if (window.userSettings.filenameNumericalSeq) { | |
| outputFileName = outputFileName[0]+"."+outputFileName.slice(1,1000).reverse().join(".") | |
| } else { | |
| outputFileName = outputFileName.reverse().join(".") | |
| } | |
| to = `${to.split("/").reverse().slice(1,10000).reverse().join("/")}/${outputFileName}` | |
| const allFiles = fs.readdirSync(`${path}/output`).filter(fname => fname.includes(from.split("/").reverse()[0].split(".")[0])) | |
| const toFolder = to.split("/").reverse().slice(1, 1000).reverse().join("/") | |
| allFiles.forEach(fname => { | |
| const ext = fname.split(".").reverse()[0] | |
| fs.copyFile(`${path}/output/${fname}`, `${toFolder}/${outputFileName}.${ext}`, err => { | |
| if (err) { | |
| console.log(err) | |
| window.appLogger.log(`Error in saveFile->outputAudio[no ffmpeg]: ${err}`) | |
| if (!fs.existsSync(from)) { | |
| window.appLogger.log(`${window.i18n.TEMP_FILE_NOT_EXIST}: ${from}`) | |
| } | |
| if (!fs.existsSync(toFolder)) { | |
| window.appLogger.log(`${window.i18n.OUT_DIR_NOT_EXIST}: ${toFolder}`) | |
| } | |
| } else { | |
| if (window.userSettings.outputJSON && window.sequenceEditor.letters.length) { | |
| fs.writeFileSync(`${to}.${toExt}.json`, JSON.stringify(jsonDataOut, null, 4)) | |
| } | |
| if (!skipUIRecord) { | |
| window.initMainPagePagination(`${window.userSettings[`outpath_${window.currentGame.gameId}`]}/${window.currentModel.voiceId}`) | |
| window.refreshRecordsList() | |
| } | |
| window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["keep-sample"]["post"], event="post keep-sample", pluginData) | |
| } | |
| }) | |
| }) | |
| } | |
| window.keepSampleFunction = shiftClick => { | |
| if (keepSampleButton.dataset.newFileLocation) { | |
| const skipUIRecord = keepSampleButton.dataset.newFileLocation.includes("BATCH_EDIT") | |
| let fromLocation = window.tempFileLocation | |
| let toLocation = keepSampleButton.dataset.newFileLocation.replace("BATCH_EDIT", "") | |
| if (!skipUIRecord) { | |
| toLocation = toLocation.split("/") | |
| toLocation[toLocation.length-1] = toLocation[toLocation.length-1].replace(/[\/\\:\*?<>"|]*/g, "") | |
| toLocation[toLocation.length-1] = toLocation[toLocation.length-1].replace(/\.wav$/, "").slice(0, window.userSettings.max_filename_chars).replace(/\.$/, "") | |
| } | |
| // Numerical file name counter | |
| if (!skipUIRecord && window.userSettings.filenameNumericalSeq) { | |
| let existingFiles = [] | |
| try { | |
| existingFiles = fs.readdirSync(toLocation.slice(0, toLocation.length-1).join("/")).filter(fname => !fname.endsWith(".json")) | |
| } catch (e) { | |
| console.log(e) | |
| } | |
| existingFiles = existingFiles.filter(fname => fname.includes(toLocation[toLocation.length-1])) | |
| existingFiles = existingFiles.map(fname => { | |
| const parts = fname.split(".") | |
| parts.reverse() | |
| if (parts.length>2 && parts.reverse()[0].length) { | |
| if (parseInt(parts[0]) != NaN) { | |
| return parseInt(parts[0]) | |
| } | |
| } | |
| return null | |
| }) | |
| existingFiles = existingFiles.filter(val => !!val) | |
| if (existingFiles.length==0) { | |
| existingFiles.push(0) | |
| } | |
| if (existingFiles.length) { | |
| existingFiles = existingFiles.sort((a,b) => {a<b?-1:1}) | |
| toLocation[toLocation.length-1] = `${toLocation[toLocation.length-1]}.${String(existingFiles[existingFiles.length-1]+1).padStart(4, "0")}` | |
| } | |
| } | |
| if (!skipUIRecord) { | |
| toLocation[toLocation.length-1] += ".wav" | |
| toLocation = toLocation.join("/") | |
| } | |
| const outFolder = toLocation.split("/").reverse().slice(2, 100).reverse().join("/") | |
| if (!fs.existsSync(outFolder)) { | |
| return void window.errorModal(`${window.i18n.OUT_DIR_NOT_EXIST}:<br><br><i>${outFolder}</i><br><br>${window.i18n.YOU_CAN_CHANGE_IN_SETTINGS}`) | |
| } | |
| // File name conflict | |
| const alreadyExists = fs.existsSync(toLocation) | |
| if (alreadyExists || shiftClick) { | |
| const promptText = alreadyExists ? window.i18n.FILE_EXISTS_ADJUST : window.i18n.ENTER_FILE_NAME | |
| createModal("prompt", { | |
| prompt: promptText, | |
| value: toLocation.split("/").reverse()[0].replace(".wav", `.${window.userSettings.audio.format}`) | |
| }).then(newFileName => { | |
| let toLocationOut = toLocation.split("/").reverse() | |
| toLocationOut[0] = newFileName.replace(`.${window.userSettings.audio.format}`, "") + `.${window.userSettings.audio.format}` | |
| let outDir = toLocationOut | |
| outDir.shift() | |
| newFileName = (newFileName.replace(`.${window.userSettings.audio.format}`, "") + `.${window.userSettings.audio.format}`).replace(/[\/\\:\*?<>"|]*/g, "") | |
| toLocationOut.reverse() | |
| toLocationOut.push(newFileName) | |
| if (fs.existsSync(outDir.slice(0, outDir.length-1).join("/"))) { | |
| const existingFiles = fs.readdirSync(outDir.slice(0, outDir.length-1).join("/")) | |
| const existingFileConflict = existingFiles.filter(name => name==newFileName) | |
| const finalOutLocation = toLocationOut.join("/") | |
| if (existingFileConflict.length) { | |
| // Remove the entry from the output files' preview | |
| Array.from(voiceSamples.querySelectorAll("div.sample")).forEach(sampleElem => { | |
| let sourceSrc = sampleElem.children[0].children[0].innerText | |
| sourceSrc = sourceSrc.split("/").reverse() | |
| const finalFileName = finalOutLocation.split("/").reverse() | |
| if (sourceSrc[0] == finalFileName[0]) { | |
| sampleElem.parentNode.removeChild(sampleElem) | |
| } | |
| }) | |
| // Remove the old file and write the new one in | |
| fs.unlink(finalOutLocation, err => { | |
| if (err) { | |
| console.log(err) | |
| window.appLogger.log(`Error in keepSample: ${err}`) | |
| } | |
| window.saveFile(fromLocation, finalOutLocation, skipUIRecord) | |
| }) | |
| return | |
| } else { | |
| window.saveFile(fromLocation, toLocationOut.join("/"), skipUIRecord) | |
| return | |
| } | |
| } | |
| window.saveFile(fromLocation, toLocationOut.join("/"), skipUIRecord) | |
| }) | |
| } else { | |
| window.saveFile(fromLocation, toLocation, skipUIRecord) | |
| } | |
| } | |
| } | |
| keepSampleButton.addEventListener("click", event => keepSampleFunction(event.shiftKey)) | |
| // Weird recursive intermittent promises to repeatedly check if the server is up yet - but it works! | |
| window.serverIsUp = false | |
| const serverStartingMessage = `${window.i18n.LOADING}...<br>${window.i18n.MAY_TAKE_A_MINUTE}<br><br>${window.i18n.STARTING_PYTHON}...` | |
| window.doWeirdServerStartupCheck = () => { | |
| const check = () => { | |
| return new Promise(topResolve => { | |
| if (window.serverIsUp) { | |
| topResolve() | |
| } else { | |
| (new Promise((resolve, reject) => { | |
| // Gather the model paths to send to the server | |
| const modelsPaths = {} | |
| Object.keys(window.userSettings).filter(key => key.includes("modelspath_")).forEach(key => { | |
| modelsPaths[key.split("_")[1]] = window.userSettings[key] | |
| }) | |
| doFetch(`http://localhost:8008/checkReady`, { | |
| method: "Post", | |
| body: JSON.stringify({ | |
| device: (window.userSettings.useGPU&&window.userSettings.installation=="gpu")?"gpu":"cpu", | |
| modelsPaths: JSON.stringify(modelsPaths) | |
| }) | |
| }).then(r => r.text()).then(r => { | |
| closeModal([document.querySelector("#activeModal"), modalContainer], [totdContainer, EULAContainer], true).then(() => { | |
| window.pluginsManager.updateUI() | |
| if (!window.pluginsManager.hasRunPostStartPlugins) { | |
| window.pluginsManager.hasRunPostStartPlugins = true | |
| window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["start"]["post"], event="post start") | |
| window.electronBrowserWindow.setProgressBar(-1) | |
| window.checkForWorkshopInstallations() | |
| } | |
| }) | |
| window.serverIsUp = true | |
| if (window.userSettings.installation=="cpu") { | |
| if (useGPUCbx.checked) { | |
| doFetch(`http://localhost:8008/setDevice`, { | |
| method: "Post", | |
| body: JSON.stringify({device: "cpu"}) | |
| }) | |
| } | |
| useGPUCbx.checked = false | |
| useGPUCbx.disabled = true | |
| window.userSettings.useGPU = false | |
| saveUserSettings() | |
| } | |
| resolve() | |
| }).catch((err) => { | |
| reject() | |
| }) | |
| })).catch(() => { | |
| setTimeout(async () => { | |
| await check() | |
| topResolve() | |
| }, 100) | |
| }) | |
| } | |
| }) | |
| } | |
| check() | |
| } | |
| window.doWeirdServerStartupCheck() | |
| modalContainer.addEventListener("click", event => { | |
| try { | |
| if (event.target==modalContainer && activeModal.dataset.type!="spinner") { | |
| closeModal() | |
| } | |
| } catch (e) {} | |
| }) | |
| // Cached UI stuff | |
| // ========= | |
| dialogueInput.addEventListener("keyup", (event) => { | |
| localStorage.setItem("dialogueInput", " "+dialogueInput.value.trim()+" ") | |
| window.sequenceEditor.hasChanged = true | |
| }) | |
| const dialogueInputCache = localStorage.getItem("dialogueInput") | |
| if (dialogueInputCache) { | |
| dialogueInput.value = dialogueInputCache | |
| } | |
| // ========= | |
| vocoder_select.value = window.userSettings.vocoder.includes(".hg.") ? "qnd" : window.userSettings.vocoder | |
| window.changeVocoder = vocoder => { | |
| return new Promise(resolve => { | |
| spinnerModal(window.i18n.CHANGING_MODELS) | |
| doFetch(`http://localhost:8008/setVocoder`, { | |
| method: "Post", | |
| body: JSON.stringify({ | |
| vocoder, | |
| modelPath: vocoder=="256_waveglow" ? window.userSettings.waveglow_path : window.userSettings.bigwaveglow_path | |
| }) | |
| }).then(r=>r.text()).then((res) => { | |
| closeModal().then(() => { | |
| setTimeout(() => { | |
| if (res=="ENOENT") { | |
| vocoder_select.value = window.userSettings.vocoder | |
| window.errorModal(`${window.i18n.BATCH_MODEL_NOT_FOUND}.${vocoder.includes("waveglow")?" "+window.i18n.BATCH_DOWNLOAD_WAVEGLOW:""}`) | |
| resolve() | |
| } else { | |
| window.batch_state.lastVocoder = vocoder | |
| window.userSettings.vocoder = vocoder | |
| saveUserSettings() | |
| resolve() | |
| } | |
| }, 300) | |
| }) | |
| }) | |
| }) | |
| } | |
| vocoder_select.addEventListener("change", () => window.changeVocoder(vocoder_select.value)) | |
| useSRCkbx.addEventListener("click", () => { | |
| let userHasSeenThisAlready = localStorage.getItem("useSRHintSeen") | |
| if (useSRCkbx.checked && !userHasSeenThisAlready) { | |
| window.confirmModal(window.i18n.USE_SR_HINT).then(resp => { | |
| if (resp) { | |
| localStorage.setItem("useSRHintSeen", "true") | |
| } | |
| }) | |
| } | |
| }) | |
| dialogueInput.addEventListener("contextmenu", event => { | |
| event.preventDefault() | |
| ipcRenderer.send('show-context-menu') | |
| }) | |
| ipcRenderer.on('context-menu-command', (e, command) => { | |
| if (command=="context-copy") { | |
| if (dialogueInput.selectionStart != dialogueInput.selectionEnd) { | |
| clipboard.writeText(dialogueInput.value.slice(dialogueInput.selectionStart, dialogueInput.selectionEnd)) | |
| } | |
| } else if (command=="context-paste") { | |
| if (clipboard.readText().length) { | |
| let newString = dialogueInput.value.slice(0, dialogueInput.selectionStart) + clipboard.readText() + dialogueInput.value.slice(dialogueInput.selectionEnd, dialogueInput.value.length) | |
| dialogueInput.value = newString | |
| } | |
| } | |
| }) | |
| window.setupModal(workbenchIcon, workbenchContainer, () => window.initVoiceWorkbench()) | |
| // Info | |
| // ==== | |
| window.setupModal(infoIcon, infoContainer) | |
| // Patreon | |
| // ======= | |
| // window.setupModal(patreonIcon, patreonContainer, () => { | |
| // const data = fs.readFileSync(`${path}/patreon.txt`, "utf8") + ", minermanb" | |
| // creditsList.innerHTML = data | |
| // }) | |
| // Updates | |
| // ======= | |
| app_version.innerHTML = window.appVersion | |
| updatesVersions.innerHTML = `${window.i18n.THIS_APP_VERSION}: ${window.appVersion}` | |
| const checkForUpdates = () => { | |
| doFetch("http://danruta.co.uk/xvasynth_updates.txt").then(r=>r.json()).then(data => { | |
| fs.writeFileSync(`${path}/updates.json`, JSON.stringify(data), "utf8") | |
| checkUpdates.innerHTML = window.i18n.CHECK_FOR_UPDATES | |
| window.showUpdates() | |
| }).catch(() => { | |
| checkUpdates.innerHTML = window.i18n.CANT_REACH_SERVER | |
| }) | |
| } | |
| window.showUpdates = () => { | |
| window.updatesLog = fs.readFileSync(`${path}/updates.json`, "utf8") | |
| window.updatesLog = JSON.parse(window.updatesLog) | |
| const sortedLogVersions = Object.keys(window.updatesLog).map( a => a.split('.').map( n => +n+100000 ).join('.') ).sort() | |
| .map( a => a.split('.').map( n => +n-100000 ).join('.') ) | |
| const appVersion = window.appVersion.replace("v", "") | |
| const appIsUpToDate = sortedLogVersions.indexOf(appVersion)==(sortedLogVersions.length-1) || sortedLogVersions.indexOf(appVersion)==-1 | |
| if (!appIsUpToDate) { | |
| update_nothing.style.display = "none" | |
| update_something.style.display = "block" | |
| updatesVersions.innerHTML = `${window.i18n.THIS_APP_VERSION}: ${appVersion}. ${window.i18n.AVAILABLE}: ${sortedLogVersions[sortedLogVersions.length-1]}` | |
| } else { | |
| updatesVersions.innerHTML = `${window.i18n.THIS_APP_VERSION}: ${appVersion}. ${window.i18n.UPTODATE}` | |
| } | |
| updatesLogList.innerHTML = "" | |
| sortedLogVersions.reverse().forEach(version => { | |
| const versionLabel = createElem("h2", version) | |
| const logItem = createElem("div", versionLabel) | |
| window.updatesLog[version].split("\n").forEach(line => { | |
| logItem.appendChild(createElem("div", line)) | |
| }) | |
| updatesLogList.appendChild(logItem) | |
| }) | |
| } | |
| checkForUpdates() | |
| window.setupModal(updatesIcon, updatesContainer) | |
| checkUpdates.addEventListener("click", () => { | |
| checkUpdates.innerHTML = window.i18n.CHECKING_FOR_UPDATES | |
| checkForUpdates() | |
| }) | |
| window.showUpdates() | |
| // Batch generation | |
| // ======== | |
| window.setupModal(batchIcon, batchGenerationContainer) | |
| // Settings | |
| // ======== | |
| window.setupModal(settingsCog, settingsContainer) | |
| // Change Game | |
| // =========== | |
| window.setupModal(changeGameButton, gameSelectionContainer) | |
| changeGameButton.addEventListener("click", () => searchGameInput.focus()) | |
| window.gameAssets = {} | |
| window.updateGameList = (doLoadAllModels=true) => { | |
| gameSelectionListContainer.innerHTML = "" | |
| const fileNames = fs.readdirSync(`${window.path}/assets`) | |
| let totalVoices = 0 | |
| let totalGames = new Set() | |
| const itemsToSort = [] | |
| // const gameIDs = doLoadAllModels ? fileNames.filter(fn=>fn.endsWith(".json")) : Object.keys(window.games).map(gID => gID+".json") | |
| const gameIDs = fileNames.filter(fn=>fn.endsWith(".json")) | |
| gameIDs.forEach(gameId => { | |
| const metadata = fs.existsSync(`${window.path}/assets/${gameId}`) ? JSON.parse(fs.readFileSync(`${window.path}/assets/${gameId}`)) : window.games[gameId.replace(".json", "")].dummyGameTheme | |
| gameId = gameId.replace(".json", "") | |
| metadata.gameId = gameId | |
| const assetFile = metadata.assetFile | |
| const gameSelection = createElem("div.gameSelection") | |
| gameSelection.style.background = `url("assets/${assetFile}")` | |
| const gameName = metadata.gameName | |
| const gameSelectionContent = createElem("div.gameSelectionContent") | |
| let numVoices = 0 | |
| const modelsPath = window.userSettings[`modelspath_${gameId}`] | |
| if (fs.existsSync(modelsPath)) { | |
| const files = fs.readdirSync(modelsPath) | |
| numVoices = files.filter(fn => fn.includes(".json")).length | |
| totalVoices += numVoices | |
| } | |
| if (numVoices==0) { | |
| gameSelectionContent.style.background = "rgba(150,150,150,0.7)" | |
| } else { | |
| gameSelectionContent.classList.add("gameSelectionContentToHover") | |
| totalGames.add(gameId) | |
| } | |
| gameSelectionContent.appendChild(createElem("div", `${numVoices} ${(numVoices>1||numVoices==0)?window.i18n.VOICE_PLURAL:window.i18n.VOICE}`)) | |
| gameSelectionContent.appendChild(createElem("div", gameName)) | |
| gameSelection.appendChild(gameSelectionContent) | |
| window.gameAssets[gameId] = metadata | |
| gameSelectionContent.addEventListener("click", () => { | |
| voiceSearchInput.focus() | |
| searchGameInput.value = "" | |
| changeGame(metadata) | |
| closeModal(gameSelectionContainer) | |
| Array.from(gameSelectionListContainer.children).forEach(elem => elem.style.display="flex") | |
| }) | |
| itemsToSort.push([numVoices, gameSelection]) | |
| const modelsDir = window.userSettings[`modelspath_${gameId}`] | |
| if (!window.watchedModelsDirs.includes(modelsDir)) { | |
| window.watchedModelsDirs.push(modelsDir) | |
| try { | |
| fs.watch(modelsDir, {recursive: false, persistent: true}, (eventType, filename) => { | |
| if (window.userSettings.autoReloadVoices) { | |
| if (doLoadAllModels) { | |
| loadAllModels().then(() => changeGame(metadata)) | |
| } | |
| } | |
| }) | |
| } catch (e) { | |
| // console.log(e) | |
| } | |
| } | |
| }) | |
| itemsToSort.sort((a,b) => a[0]<b[0]?1:-1).forEach(([numVoices, elem]) => { | |
| gameSelectionListContainer.appendChild(elem) | |
| }) | |
| searchGameInput.addEventListener("keyup", (event) => { | |
| if (event.key=="Enter") { | |
| const voiceElems = Array.from(gameSelectionListContainer.children).filter(elem => elem.style.display=="flex") | |
| if (voiceElems.length==1) { | |
| voiceElems[0].children[0].click() | |
| searchGameInput.value = "" | |
| } | |
| } | |
| const voiceElems = Array.from(gameSelectionListContainer.children) | |
| if (searchGameInput.value.length) { | |
| voiceElems.forEach(elem => { | |
| if (elem.children[0].children[1].innerHTML.toLowerCase().includes(searchGameInput.value)) { | |
| elem.style.display="flex" | |
| } else { | |
| elem.style.display="none" | |
| } | |
| }) | |
| } else { | |
| voiceElems.forEach(elem => elem.style.display="block") | |
| } | |
| }) | |
| searchGameInput.placeholder = window.i18n.SEARCH_N_GAMES_WITH_N2_VOICES.replace("_1", Array.from(totalGames).length).replace("_2", totalVoices) | |
| if (doLoadAllModels) { | |
| loadAllModels().then(() => { | |
| // Load the last selected game | |
| const lastGame = localStorage.getItem("lastGame") | |
| if (lastGame) { | |
| changeGame(JSON.parse(lastGame)) | |
| } | |
| }) | |
| } | |
| } | |
| window.updateGameList() | |
| // Embeddings | |
| // ========== | |
| window.setupModal(embeddingsIcon, embeddingsContainer, () => { | |
| setTimeout(() => { | |
| if (window.embeddingsState.isReady) { | |
| window.embeddings_updateSize() | |
| } | |
| }, 100) | |
| window.embeddings_updateSize() | |
| window.embeddingsState.isOpen = true | |
| if (!window.embeddingsState.ready) { | |
| setTimeout(() => { | |
| window.embeddingsState.ready = true | |
| window.initEmbeddingsScene() | |
| setTimeout(() => { | |
| window.computeEmbsAndDimReduction(true) | |
| }, 300) | |
| }, 100) | |
| } | |
| }, () => { | |
| window.embeddingsState.isOpen = false | |
| }) | |
| // Arpabet | |
| // ======= | |
| window.setupModal(arpabetIcon, arpabetContainer, () => setTimeout(()=> !window.arpabetMenuState.hasInitialised && window.refreshDictionariesList(), 100)) | |
| // Plugins | |
| // ======= | |
| window.setupModal(pluginsIcon, pluginsContainer) | |
| window.setupModal(style_emb_manage_btn, styleEmbeddingsContainer, window.styleEmbsModalOpenCallback) | |
| // Other | |
| // ===== | |
| window.setupModal(reset_what_open_btn, resetContainer) | |
| window.setupModal(i18n_batch_metadata_open_btn, batchMetadataCSVContainer) | |
| voiceSearchInput.addEventListener("keyup", () => { | |
| if (event.key=="Enter") { | |
| const voiceElems = Array.from(voiceTypeContainer.children).filter(elem => elem.style.display=="block") | |
| if (voiceElems.length==1) { | |
| voiceElems[0].click() | |
| generateVoiceButton.click() | |
| voiceSearchInput.value = "" | |
| } | |
| } | |
| const voiceElems = Array.from(voiceTypeContainer.children) | |
| if (voiceSearchInput.value.length) { | |
| voiceElems.forEach(elem => { | |
| if (elem.innerHTML.toLowerCase().includes(voiceSearchInput.value)) { | |
| elem.style.display="block" | |
| } else { | |
| elem.style.display="none" | |
| } | |
| }) | |
| } else { | |
| voiceElems.forEach(elem => elem.style.display="block") | |
| } | |
| }) | |
| // Splash/EULA | |
| splashNextButton1.addEventListener("click", () => { | |
| splash_screen1.style.display = "none" | |
| splash_screen2.style.display = "flex" | |
| }) | |
| EULA_closeButon.addEventListener("click", () => { | |
| if (EULA_accept_ckbx.checked) { | |
| closeModal(EULAContainer) | |
| window.userSettings.EULA_accepted_2023 = true | |
| saveUserSettings() | |
| if (!window.totd_state.startupChecked) { | |
| window.showTipIfEnabledAndNewDay().then(() => { | |
| if (!serverIsUp) { | |
| spinnerModal(serverStartingMessage) | |
| } | |
| }) | |
| } | |
| if (!serverIsUp && totdContainer.style.display=="none") { | |
| window.spinnerModal(serverStartingMessage) | |
| } | |
| } | |
| }) | |
| if (!Object.keys(window.userSettings).includes("EULA_accepted_2023") || !window.userSettings.EULA_accepted_2023) { | |
| EULAContainer.style.opacity = 0 | |
| EULAContainer.style.display = "flex" | |
| requestAnimationFrame(() => requestAnimationFrame(() => EULAContainer.style.opacity = 1)) | |
| requestAnimationFrame(() => requestAnimationFrame(() => chromeBar.style.opacity = 1)) | |
| } else { | |
| window.showTipIfEnabledAndNewDay().then(() => { | |
| // If not, or the user closed the window quickly, show the server is starting message if still booting up | |
| if (!window.serverIsUp) { | |
| spinnerModal(serverStartingMessage) | |
| } | |
| }) | |
| } | |
| // Links | |
| document.querySelectorAll('a[href^="http"]').forEach(a => a.addEventListener("click", e => { | |
| event.preventDefault() | |
| shell.openExternal(a.href) | |
| })) | |