@quenty/clienttranslator 14.5.0 → 14.6.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [14.6.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/clienttranslator@14.5.0...@quenty/clienttranslator@14.6.0) (2024-09-12)
+
+
+### Features
+
+* Unedited all changes ([60e64e3](https://github.com/Quenty/NevermoreEngine/commit/60e64e3efce17c10c4b8965871187d231b338dd4))
+
+
+
+
+
 # [14.5.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/clienttranslator@14.4.0...@quenty/clienttranslator@14.5.0) (2024-08-09)
 
 **Note:** Version bump only for package @quenty/clienttranslator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/clienttranslator",
-  "version": "14.5.0",
+  "version": "14.6.0",
   "description": "Gets local translator for player",
   "keywords": [
     "Roblox",
@@ -25,18 +25,20 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/blend": "^12.4.0",
-    "@quenty/instanceutils": "^13.4.0",
-    "@quenty/loader": "^10.3.0",
-    "@quenty/maid": "^3.2.0",
-    "@quenty/promise": "^10.3.0",
+    "@quenty/blend": "^12.5.0",
+    "@quenty/instanceutils": "^13.5.0",
+    "@quenty/loader": "^10.4.0",
+    "@quenty/maid": "^3.3.0",
+    "@quenty/promise": "^10.4.0",
+    "@quenty/promisemaid": "^5.4.0",
     "@quenty/pseudolocalize": "^3.3.0",
-    "@quenty/rx": "^13.4.0",
+    "@quenty/rx": "^13.5.0",
     "@quenty/string": "^3.2.0",
-    "@quenty/table": "^3.5.0"
+    "@quenty/table": "^3.5.0",
+    "@quenty/valueobject": "^13.5.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ba466bdbc05c42fb607cf5e228c16339201d21d7"
+  "gitHead": "fb172906f3ee725269ec1e5f4daf9dca227e729d"
 }

package/src/Shared/Conversion/LocalizationEntryParserUtils.lua

@@ -0,0 +1,114 @@
+--[=[
+	Utility to build a localization table from json, intended to be used with rojo. Can also handle Rojo json
+	objects turned into tables!
+
+	@class LocalizationEntryParserUtils
+]=]
+
+local HttpService = game:GetService("HttpService")
+local RunService = game:GetService("RunService")
+
+local require = require(script.Parent.loader).load(script)
+
+local PseudoLocalize = require("PseudoLocalize")
+
+local LocalizationEntryParserUtils = {}
+
+function LocalizationEntryParserUtils.decodeFromInstance(tableName, sourceLocaleId, folder)
+	assert(type(tableName) == "string", "Bad tableName")
+	assert(typeof(folder) == "Instance", "Bad folder")
+
+	local lookupTable = {}
+	local baseKey = ""
+
+	for _, descendant in pairs(folder:GetDescendants()) do
+		if descendant:IsA("StringValue") then
+			local localeId = LocalizationEntryParserUtils._parseLocaleFromName(descendant.Name)
+			local decodedTable = HttpService:JSONDecode(descendant.Value)
+
+			LocalizationEntryParserUtils._parseTableToResultsList(lookupTable, sourceLocaleId, localeId, baseKey, decodedTable, tableName)
+		elseif descendant:IsA("ModuleScript") then
+			local localeId = LocalizationEntryParserUtils._parseLocaleFromName(descendant.Name)
+			local decodedTable = require(descendant)
+
+			LocalizationEntryParserUtils._parseTableToResultsList(lookupTable, sourceLocaleId, localeId, baseKey, decodedTable, tableName)
+		end
+	end
+
+	local results = {}
+	for _, item in pairs(lookupTable) do
+		table.insert(results, item)
+	end
+	return results
+end
+
+function LocalizationEntryParserUtils.decodeFromTable(tableName, localeId, dataTable)
+	assert(type(tableName) == "string", "Bad tableName")
+	assert(type(localeId) == "string", "Bad localeId")
+	assert(type(dataTable) == "table", "Bad dataTable")
+
+	local lookupTable = {}
+
+	local baseKey = ""
+	LocalizationEntryParserUtils._parseTableToResultsList(lookupTable, localeId, localeId, baseKey, dataTable, tableName)
+
+	local results = {}
+	for _, item in pairs(lookupTable) do
+		table.insert(results, item)
+	end
+	return results
+end
+
+function LocalizationEntryParserUtils._parseLocaleFromName(name)
+	if name:sub(-5) == ".json" then
+		return name:sub(1, #name-5)
+	else
+		return name
+	end
+end
+
+function LocalizationEntryParserUtils._parseTableToResultsList(lookupTable, sourceLocaleId, localeId, baseKey, dataTable, tableName)
+	assert(type(lookupTable) == "table", "Bad lookupTable")
+	assert(type(sourceLocaleId) == "string", "Bad sourceLocaleId")
+	assert(type(localeId) == "string", "Bad localeId")
+	assert(type(baseKey) == "string", "Bad baseKey")
+	assert(type(dataTable) == "table", "Bad dataTable")
+	assert(type(tableName) == "string", "Bad tableName")
+
+	for index, text in pairs(dataTable) do
+		local key = baseKey .. index
+		if type(text) == "table" then
+			LocalizationEntryParserUtils._parseTableToResultsList(lookupTable, sourceLocaleId, localeId, key .. ".", text, tableName)
+		elseif type(text) == "string" then
+			local found = lookupTable[key]
+			if found then
+				found.Values[localeId] = key
+			else
+				-- Guarantee the context is unique. This is important because Roblox will not
+				-- allow something with the same source without a differing context text.
+				local context = string.format("Generated from %s with key %s", tableName, key)
+
+				found = {
+					Context = context;
+					Example = text;
+					Key = key;
+					Source = sourceLocaleId;
+					Values = {
+						[localeId] = text;
+					};
+				};
+
+				if RunService:IsStudio() and sourceLocaleId == localeId then
+					found.Values[PseudoLocalize.getDefaultPseudoLocaleId()] = PseudoLocalize.pseudoLocalize(text)
+				end
+
+				lookupTable[key] = found;
+			end
+
+		else
+			error(string.format("Bad type for text at key '%s'", key))
+		end
+	end
+end
+
+return LocalizationEntryParserUtils

package/src/Shared/JSONTranslator.lua

@@ -15,19 +15,17 @@
 
 local require = require(script.Parent.loader).load(script)
 
-local Players = game:GetService("Players")
 local RunService = game:GetService("RunService")
 
 local Blend = require("Blend")
-local JsonToLocalizationTable = require("JsonToLocalizationTable")
-local LocalizationServiceUtils = require("LocalizationServiceUtils")
+local LocalizationEntryParserUtils = require("LocalizationEntryParserUtils")
 local Maid = require("Maid")
-local Observable = require("Observable")
-local Promise = require("Promise")
 local PseudoLocalize = require("PseudoLocalize")
 local Rx = require("Rx")
 local RxInstanceUtils = require("RxInstanceUtils")
 local TranslationKeyUtils = require("TranslationKeyUtils")
+local TranslatorService = require("TranslatorService")
+local ValueObject = require("ValueObject")
 
 local JSONTranslator = {}
 JSONTranslator.ClassName = "JSONTranslator"
@@ -60,28 +58,26 @@ JSONTranslator.__index = JSONTranslator
 	```
 
 	@param translatorName string -- Name of the translator. Used for source.
-	@param ... any
+	@param localeId string
+	@param dataTable table
 	@return JSONTranslator
 ]=]
-function JSONTranslator.new(translatorName, ...)
+function JSONTranslator.new(translatorName, localeId, dataTable)
+	assert(type(translatorName) == "string", "Bad translatorName")
+
 	local self = setmetatable({}, JSONTranslator)
 
-	assert(type(translatorName) == "string", "Bad translatorName")
+	self._translatorName = translatorName
 	self.ServiceName = translatorName
 
-	-- Cache localizaiton table, because it can take 10-20ms to load.
-	self._localizationTable = JsonToLocalizationTable.toLocalizationTable(translatorName, ...)
-	self._englishTranslator = self._localizationTable:GetTranslator("en")
-	self._fallbacks = {}
-
-	if RunService:IsRunning() and RunService:IsClient() then
-		self._promiseTranslator = LocalizationServiceUtils.promiseTranslator(Players.LocalPlayer)
+	if type(localeId) == "string" and type(dataTable) == "table" then
+		self._entries = LocalizationEntryParserUtils.decodeFromTable(self._translatorName, localeId, dataTable)
+	elseif typeof(localeId) == "Instance" then
+		local parent = localeId
+		local sourceLocaleId = "en"
+		self._entries = LocalizationEntryParserUtils.decodeFromInstance(self._translatorName, sourceLocaleId, parent)
 	else
-		self._promiseTranslator = Promise.resolved(self._englishTranslator)
-	end
-
-	if RunService:IsStudio() then
-		PseudoLocalize.addToLocalizationTable(self._localizationTable, nil, "en")
+		error("Must pass a localeId and dataTable")
 	end
 
 	return self
@@ -89,6 +85,99 @@ end
 
 function JSONTranslator:Init(serviceBag)
 	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._translatorService = self._serviceBag:GetService(TranslatorService)
+
+	self._maid = Maid.new()
+	self._localTranslator = self._maid:Add(ValueObject.new(nil))
+	self._sourceTranslator = self._maid:Add(ValueObject.new(nil))
+
+	self._localizationTable = self._translatorService:GetLocalizationTable()
+
+	for _, item in pairs(self._entries) do
+		for localeId, text in pairs(item.Values) do
+			self._localizationTable:SetEntryValue(item.Key, item.Source, item.Context, localeId, text)
+		end
+		self._localizationTable:SetEntryExample(item.Key, item.Source, item.Context, item.Example)
+	end
+
+	self._maid:GiveTask(RxInstanceUtils.observeProperty(self._localizationTable, "SourceLocaleId"):Subscribe(function(localeId)
+		self._sourceTranslator.Value = self._localizationTable:GetTranslator(localeId)
+	end))
+	self._maid:GiveTask(self._translatorService:ObserveLocaleId():Subscribe(function(localeId)
+		self._localTranslator.Value = self._localizationTable:GetTranslator(localeId)
+	end))
+end
+
+--[=[
+	Observes the translated value
+	@param translationKey string
+	@param translationArgs table? -- May have observables (or convertable to observables) in it.
+	@return Observable<string>
+]=]
+function JSONTranslator:ObserveFormatByKey(translationKey, translationArgs)
+	assert(self ~= JSONTranslator, "Construct a new version of this class to use it")
+	assert(type(translationKey) == "string", "Key must be a string")
+
+	return Rx.combineLatest({
+		translator = self:ObserveTranslator();
+		translationKey = translationKey;
+		translationArgs = self:_observeArgs(translationArgs);
+	}):Pipe({
+		Rx.switchMap(function(mainState)
+			if mainState.translator then
+				return Rx.of(self:_doTranslation(mainState.translator, mainState.translationKey, mainState.translationArgs))
+			end
+
+			-- Fall back to local or source translator
+			return Rx.combineLatest({
+				localTranslator = self._localTranslator:Observe();
+				sourceTranslator = self._sourceTranslator:Observe();
+			}):Pipe({
+				Rx.map(function(state)
+					if state.localTranslator then
+						return self:_doTranslation(state.localTranslator, mainState.translationKey, mainState.translationArgs)
+					elseif state.sourceTranslator then
+						return self:_doTranslation(state.sourceTranslator, mainState.translationKey, mainState.translationArgs)
+					else
+						return nil
+					end
+				end);
+				Rx.where(function(value)
+					return value ~= nil
+				end);
+			})
+		end)
+	})
+end
+
+--[=[
+	Formats the resulting entry by args.
+
+	:::tip
+	You should use [JSONTranslator.ObserveFormatByKey] instead of this to respond
+	to locale changing.
+	:::
+
+	@param translationKey string
+	@param args table?
+	@return Promise<string>
+]=]
+function JSONTranslator:PromiseFormatByKey(translationKey, args)
+	assert(self ~= JSONTranslator, "Construct a new version of this class to use it")
+	assert(type(translationKey) == "string", "Key must be a string")
+
+	-- Always waits for full translator to be loaded since we only get one shot
+	return self:PromiseTranslator():Then(function(translator)
+		return self:_doTranslation(translator, translationKey, args)
+	end)
+end
+
+function JSONTranslator:PromiseTranslator()
+	return self._translatorService:PromiseTranslator()
+end
+
+function JSONTranslator:ObserveTranslator()
+	return self._translatorService:ObserveTranslator()
 end
 
 --[=[
@@ -97,11 +186,7 @@ end
 	@return Observable<string>
 ]=]
 function JSONTranslator:ObserveLocaleId()
-	return Rx.fromPromise(self._promiseTranslator):Pipe({
-		Rx.switchMap(function(translator)
-			return RxInstanceUtils.observeProperty(translator, "LocaleId")
-		end)
-	})
+	return self._translatorService:ObserveLocaleId()
 end
 
 --[=[
@@ -125,17 +210,15 @@ function JSONTranslator:SetEntryValue(translationKey, source, context, localeId,
 	self._localizationTable:SetEntryValue(translationKey, source, context, localeId, text or source)
 
 	if RunService:IsStudio() then
-		self._localizationTable:SetEntryValue(translationKey, source, context,
-			PseudoLocalize.getDefaultPseudoLocaleId(),
-			PseudoLocalize.pseudoLocalize(text))
+		self._localizationTable:SetEntryValue(translationKey, source, context, PseudoLocalize.getDefaultPseudoLocaleId(), PseudoLocalize.pseudoLocalize(text))
 	end
 end
 
-function JSONTranslator:ObserveTranslation(prefix, text, argData)
+function JSONTranslator:ObserveTranslation(prefix, text, translationArgs)
 	assert(type(prefix) == "string", "Bad text")
 	assert(type(text) == "string", "Bad text")
 
-	return self:ObserveFormatByKey(self:ToTranslationKey(prefix, text), argData)
+	return self:ObserveFormatByKey(self:ToTranslationKey(prefix, text), translationArgs)
 end
 
 function JSONTranslator:ToTranslationKey(prefix, text)
@@ -157,13 +240,7 @@ end
 	@return string
 ]=]
 function JSONTranslator:GetLocaleId()
-	if self._promiseTranslator:IsFulfilled() then
-		local translator = self._promiseTranslator:Wait()
-		return translator.LocaleId
-	else
-		warn("[JSONTranslator.GetLocaleId] - Translator is not loaded yet, returning english")
-		return "en"
-	end
+	return self._translatorService:GetLocaleId()
 end
 
 --[=[
@@ -180,188 +257,98 @@ end
 	@return Promise
 ]=]
 function JSONTranslator:PromiseLoaded()
-	return self._promiseTranslator
-end
-
---[=[
-	Makes the translator fall back to another translator if an entry cannot be found.
-
-	Mostly just used for testing.
-
-	@param translator JSONTranslator | Translator
-]=]
-function JSONTranslator:FallbackTo(translator)
-	assert(translator, "Bad translator")
-	assert(translator.FormatByKey, "Bad translator")
-
-	table.insert(self._fallbacks, translator)
+	return self:PromiseTranslator()
 end
 
 --[=[
-	Formats the resulting entry by args.
+	Formats or errors if the cloud translations are not loaded.
 
 	:::tip
 	You should use [JSONTranslator.ObserveFormatByKey] instead of this to respond
 	to locale changing.
 	:::
 
-	@param key string
+	@param translationKey string
 	@param args table?
-	@return Promise<string>
-]=]
-function JSONTranslator:PromiseFormatByKey(key, args)
-	assert(self ~= JSONTranslator, "Construct a new version of this class to use it")
-	assert(type(key) == "string", "Key must be a string")
-
-	return self._promiseTranslator:Then(function()
-		return self:FormatByKey(key, args)
-	end)
-end
-
---[=[
-	Observes the translated value
-	@param key string
-	@param argData table? -- May have observables (or convertable to observables) in it.
-	@return Observable<string>
+	@return string
 ]=]
-function JSONTranslator:ObserveFormatByKey(key, argData)
+function JSONTranslator:FormatByKey(translationKey, args)
 	assert(self ~= JSONTranslator, "Construct a new version of this class to use it")
-	assert(type(key) == "string", "Key must be a string")
-
-	local argObservable
-	if argData then
-		local args = {}
-		for argKey, value in pairs(argData) do
-			args[argKey] = Blend.toPropertyObservable(value) or Rx.of(value)
-		end
+	assert(type(translationKey) == "string", "Key must be a string")
 
-		argObservable = Rx.combineLatest(args)
-	else
-		argObservable = nil
+	local translator = self._translatorService:GetTranslator()
+	if not translator then
+		error("Translator is not yet acquired yet")
 	end
 
-	return Observable.new(function(sub)
-		local maid = Maid.new()
-
-		maid:GivePromise(self._promiseTranslator):Then(function(translator)
-			if argObservable then
-				maid:GiveTask(Rx.combineLatest({
-					localeId = RxInstanceUtils.observeProperty(translator, "LocaleId");
-					args = argObservable;
-				}):Subscribe(function(state)
-					sub:Fire(self:FormatByKey(key, state.args))
-				end))
-			else
-				maid:GiveTask(RxInstanceUtils.observeProperty(translator, "LocaleId"):Subscribe(function()
-					sub:Fire(self:FormatByKey(key, nil))
-				end))
-			end
-		end)
-
-		return maid
-	end)
+	return self:_doTranslation(translator, translationKey, args)
 end
 
---[=[
-	Formats or errors if the cloud translations are not loaded.
-
-	:::tip
-	You should use [JSONTranslator.ObserveFormatByKey] instead of this to respond
-	to locale changing.
-	:::
-
-	@param key string
-	@param args table?
-	@return string
-]=]
-function JSONTranslator:FormatByKey(key, args)
-	assert(self ~= JSONTranslator, "Construct a new version of this class to use it")
-	assert(type(key) == "string", "Key must be a string")
+function JSONTranslator:_observeArgs(translationArgs)
+	if translationArgs == nil then
+		return Rx.of(nil)
+	end
 
-	if not RunService:IsRunning() then
-		return self:_formatByKeyTestMode(key, args)
+	local args = {}
+	for argKey, value in pairs(translationArgs) do
+		args[argKey] = Blend.toPropertyObservable(value) or Rx.of(value)
 	end
 
-	local clientTranslator = self:_getClientTranslatorOrError()
+	return Rx.combineLatest(args)
+end
+
+function JSONTranslator:_doTranslation(translator, translationKey, args)
+	assert(typeof(translator) == "Instance", "Bad translator")
+	assert(type(translationKey) == "string", "Bad translationKey")
 
-	local result
+	local translation
 	local ok, err = pcall(function()
-		result = clientTranslator:FormatByKey(key, args)
+		translation = translator:FormatByKey(translationKey, args)
 	end)
 
-	if ok and not err then
-		return result
+	if translation then
+		return translation
 	end
 
 	if err then
 		warn(err)
 	else
-		warn("Failed to localize '" .. key .. "'")
+		warn("Failed to localize '" .. translationKey .. "'")
 	end
 
-	-- Fallback to English
-	if clientTranslator.LocaleId ~= self._englishTranslator.LocaleId then
-		-- Ignore results as we know this may error
+	-- Try the local translator next (not from cloud)
+	local localTranslator = self._localTranslator.Value
+	if localTranslator then
 		ok, err = pcall(function()
-			result = self._englishTranslator:FormatByKey(key, args)
+			translation = localTranslator:FormatByKey(translationKey, args)
 		end)
 
-		if ok and not err then
-			return result
+		if translation then
+			return translation
 		end
 	end
 
-	return key
-end
-
-function JSONTranslator:_getClientTranslatorOrError()
-	assert(self._promiseTranslator, "ClientTranslator is not initialized")
-
-	if self._promiseTranslator:IsFulfilled() then
-		return assert(self._promiseTranslator:Wait(), "Failed to get translator")
-	else
-		error("Translator is not yet acquired yet")
-		return nil
+	-- Try the source translator next (we're missing the locale id)
+	local sourceTranslator = self._sourceTranslator.Value
+	if sourceTranslator then
+		ok, err = pcall(function()
+			translation = sourceTranslator:FormatByKey(translationKey, args)
+		end)
 	end
-end
-
-function JSONTranslator:_formatByKeyTestMode(key, args)
-	-- Can't read LocalizationService.ForcePlayModeRobloxLocaleId :(
-	local translator = self._localizationTable:GetTranslator("en")
-	local result
-	local ok, err = pcall(function()
-		result = translator:FormatByKey(key, args)
-	end)
 
 	if ok and not err then
-		return result
-	end
-
-	for _, fallback in pairs(self._fallbacks) do
-		local value = fallback:FormatByKey(key, args)
-		if value then
-			return value
-		end
+		return translation
 	end
 
-	if err then
-		warn(err)
-	else
-		warn("[JSONTranslator._formatByKeyTestMode] - Failed to localize '" .. key .. "'")
-	end
-
-	return key
+	return translationKey
 end
 
 --[=[
 	Cleans up the translator and deletes the localization table if it exists.
+	Should be called by [ServiceBag]
 ]=]
 function JSONTranslator:Destroy()
-	self._localizationTable:Destroy()
-	self._localizationTable = nil
-	self._englishTranslator = nil
-	self._promiseTranslator = nil
-
+	self._maid:DoCleaning()
 	setmetatable(self, nil)
 end
 

package/src/Shared/TranslatorService.lua

@@ -0,0 +1,212 @@
+--[=[
+	Handles selecting the right locale/translator for Studio, and Roblox games.
+
+	@class TranslatorService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Players = game:GetService("Players")
+local RunService = game:GetService("RunService")
+local LocalizationService = game:GetService("LocalizationService")
+
+local RxInstanceUtils = require("RxInstanceUtils")
+local Rx = require("Rx")
+local LocalizationServiceUtils = require("LocalizationServiceUtils")
+local ValueObject = require("ValueObject")
+local Maid = require("Maid")
+local Promise = require("Promise")
+
+local TranslatorService = {}
+TranslatorService.ServiceName = "TranslatorService"
+
+function TranslatorService:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+
+	self._translator = self._maid:Add(ValueObject.new(nil))
+	self._translator:Mount(self:_observeTranslatorImpl())
+end
+
+function TranslatorService:GetLocalizationTable()
+	if self._localizationTable then
+		return self._localizationTable
+	end
+
+	local localizationTableName = self:_getLocalizationTableName()
+	local localizationTable = LocalizationService:FindFirstChild(localizationTableName)
+
+	if not localizationTable then
+		localizationTable = Instance.new("LocalizationTable")
+		localizationTable.Name = localizationTableName
+		localizationTable.Parent = LocalizationService
+	end
+
+	self._localizationTable = localizationTable
+	return localizationTable
+end
+
+function TranslatorService:_getLocalizationTableName()
+	if RunService:IsServer() then
+		return "GeneratedJSONTable_Server"
+	else
+		return "GeneratedJSONTable_Client"
+	end
+end
+
+--[=[
+	Observes Roblox translator
+
+	@return Observable<Translator>
+]=]
+function TranslatorService:ObserveTranslator()
+	return self._translator:Observe()
+end
+
+--[=[
+	Promises the Roblox translator
+
+	@return Observable<Translator>
+]=]
+function TranslatorService:PromiseTranslator()
+	local found = self._translator.Value
+	if found then
+		return Promise.resolved(found)
+	end
+
+	if self._pendingTranslatorPromise then
+		return self._pendingTranslatorPromise
+	end
+
+	local maid = Maid.new()
+	local promise = maid:Add(Promise.new())
+
+	self._maid._pendingTranslatorMaid = maid
+	self._pendingTranslatorPromise = promise
+
+	maid:GiveTask(function()
+		if self._maid._pendingTranslatorMaid == maid then
+			self._maid._pendingTranslatorMaid = nil
+		end
+
+		if self._pendingTranslatorPromise == promise then
+			self._pendingTranslatorPromise = nil
+		end
+	end)
+
+	maid:GiveTask(self._translator:Observe():Subscribe(function(translator)
+		if translator then
+			promise:Resolve(translator)
+		end
+	end))
+
+	return promise
+end
+
+--[=[
+	Gets the current translator to use
+
+	@return Translator?
+]=]
+function TranslatorService:GetTranslator()
+	return self._translator.Value
+end
+
+--[=[
+	Observes the current locale id for this translator.
+
+	@return Observable<string>
+]=]
+function TranslatorService:ObserveLocaleId()
+	return self._translator:Observe():Pipe({
+		Rx.switchMap(function(translator)
+			if translator then
+				return RxInstanceUtils.observeProperty(translator, "LocaleId")
+			else
+				-- Fallback
+				return self:_observeLoadedPlayer():Pipe({
+					Rx.switchMap(function(player)
+						if player then
+							return RxInstanceUtils.observeProperty(player, "LocaleId")
+						else
+							return RxInstanceUtils.observeProperty(LocalizationService, "RobloxLocaleId")
+						end
+					end)
+				})
+			end
+		end);
+		Rx.distinct();
+	})
+end
+
+--[=[
+	Gets the localeId to use
+
+	@return string
+]=]
+function TranslatorService:GetLocaleId()
+	local found = self._translator.Value
+	if found then
+		return found.LocaleId
+	end
+
+	-- Fallback
+	local player = Players.LocalPlayer
+	if player and player.LocaleId ~= "" then
+		return player.LocaleId
+	else
+		return LocalizationService.RobloxLocaleId
+	end
+end
+
+function TranslatorService:_observeTranslatorImpl()
+	return self:_observeLoadedPlayer():Pipe({
+		Rx.switchMap(function(loadedPlayer)
+			if loadedPlayer then
+				return Rx.fromPromise(LocalizationServiceUtils.promisePlayerTranslator(loadedPlayer))
+			end
+
+			return RxInstanceUtils.observeProperty(LocalizationService, "RobloxLocaleId"):Pipe({
+				Rx.switchMap(function(localeId)
+					-- This can actually take a while (20-30 seconds)
+					return Rx.fromPromise(LocalizationServiceUtils.promiseTranslatorForLocale(localeId))
+				end)
+			})
+		end);
+	})
+end
+
+function TranslatorService:_observeLoadedPlayer()
+	if self._loadedPlayerObservable then
+		return self._loadedPlayerObservable
+	end
+
+	self._loadedPlayerObservable = RxInstanceUtils.observeProperty(Players, "LocalPlayer"):Pipe({
+		Rx.switchMap(function(player)
+			if not player then
+				return Rx.of(nil)
+			end
+
+			return RxInstanceUtils.observeProperty(player, "LocaleId"):Pipe({
+				Rx.map(function(localeId)
+					if localeId == "" then
+						return nil
+					else
+						return player
+					end
+				end);
+			})
+		end);
+		Rx.distinct();
+		Rx.cache();
+	})
+
+	return self._loadedPlayerObservable
+end
+
+function TranslatorService:Destroy()
+	self._maid:DoCleaning()
+end
+
+return TranslatorService

package/src/Shared/Utils/LocalizationServiceUtils.lua

@@ -8,53 +8,64 @@ local LocalizationService = game:GetService("LocalizationService")
 local RunService = game:GetService("RunService")
 
 local Promise = require("Promise")
+local PromiseMaidUtils = require("PromiseMaidUtils")
+
+local TIMEOUT = 20
+if RunService:IsStudio() then
+	TIMEOUT = 0.5
+end
+
 local ERROR_PUBLISH_REQUIRED = "Publishing the game is required to use GetTranslatorForPlayerAsync API."
+local ERROR_TIMEOUT = string.format("GetTranslatorForPlayerAsync is still pending after %f, using local table", TIMEOUT)
 
 local LocalizationServiceUtils = {}
 
-function LocalizationServiceUtils.promiseTranslator(player)
-	local asyncTranslatorPromise = Promise.spawn(function(resolve, reject)
+function LocalizationServiceUtils.promiseTranslatorForLocale(localeId)
+	return Promise.spawn(function(resolve, reject)
 		local translator = nil
 		local ok, err = pcall(function()
-			translator = LocalizationService:GetTranslatorForPlayerAsync(player)
+			translator = LocalizationService:GetTranslatorForLocaleAsync(localeId)
 		end)
 
 		if not ok then
-			reject(err or "Failed to GetTranslatorForPlayerAsync")
-			return
+			return reject(err or "Failed to GetTranslatorForLocaleAsync")
 		end
 
-		if translator then
-			assert(typeof(translator) == "Instance", "Bad translator")
-			resolve(translator)
-			return
+		if typeof(translator) ~= "Instance" then
+			return reject("Translator was not returned")
 		end
 
-		reject("Translator was not returned")
-		return
+		return resolve(translator)
 	end)
+end
 
-	-- Give longer in non-studio mode
-	local timeout = 20
-	if RunService:IsStudio() then
-		timeout = 0.5
-	end
+function LocalizationServiceUtils.promisePlayerTranslator(player)
+	local promiseTranslator = Promise.spawn(function(resolve, reject)
+		local translator = nil
+		local ok, err = pcall(function()
+			translator = LocalizationService:GetTranslatorForPlayerAsync(player)
+		end)
+
+		if not ok then
+			return reject(err or "Failed to GetTranslatorForPlayerAsync")
+		end
 
-	local rejectedCauseOfTimeout = false
-	task.delay(timeout, function()
-		if not asyncTranslatorPromise:IsPending() then
-			return
+		if typeof(translator) ~= "Instance" then
+			return reject("Translator was not returned")
 		end
 
-		rejectedCauseOfTimeout = true
-		asyncTranslatorPromise:Reject(
-			("GetTranslatorForPlayerAsync is still pending after %f, using local table")
-			:format(timeout))
+		return resolve(translator)
 	end)
 
-	return asyncTranslatorPromise:Catch(function(err)
-		if err ~= ERROR_PUBLISH_REQUIRED and not rejectedCauseOfTimeout then
-			warn(("[LocalizationServiceUtils.promiseTranslator] - %s"):format(tostring(err)))
+	PromiseMaidUtils.whilePromise(promiseTranslator, function(maid)
+		maid:GiveTask(task.delay(TIMEOUT, function()
+			promiseTranslator:Reject(ERROR_TIMEOUT)
+		end))
+	end)
+
+	return promiseTranslator:Catch(function(err)
+		if err ~= ERROR_PUBLISH_REQUIRED and error ~= ERROR_TIMEOUT then
+			warn(string.format("[LocalizationServiceUtils.promisePlayerTranslator] - %s", tostring(err)))
 		end
 
 		-- Fallback to just local stuff
@@ -63,5 +74,4 @@ function LocalizationServiceUtils.promiseTranslator(player)
 	end)
 end
 
-
 return LocalizationServiceUtils

package/src/Shared/Conversion/JsonToLocalizationTable.lua

@@ -1,174 +0,0 @@
---[=[
-	Utility to build a localization table from json, intended to be used with rojo. Can also handle Rojo json
-	objects turned into tables!
-
-	@class JsonToLocalizationTable
-]=]
-
-local LocalizationService = game:GetService("LocalizationService")
-local HttpService = game:GetService("HttpService")
-local RunService = game:GetService("RunService")
-
-local JsonToLocalizationTable = {}
-
-local LOCALIZATION_TABLE_NAME_CLIENT = "GeneratedJSONTable_Client"
-local LOCALIZATION_TABLE_NAME_SERVER = "GeneratedJSONTable_Server"
-
---[[
-	Recursively iterates through the object to construct strings and add it to the localization table
-
-	@param localizationTable LocalizationTable
-	@param localeId string -- The localizationid to add
-	@param baseKey string -- the key to add
-	@param object any -- The value to iterate over
-]]
-local function recurseAdd(localizationTable, localeId, baseKey, object, tableName)
-	if baseKey ~= "" then
-		baseKey = baseKey .. "."
-	end
-
-	for index, value in pairs(object) do
-		local key = baseKey .. index
-		if type(value) == "table" then
-			recurseAdd(localizationTable, localeId, key, value, tableName)
-		elseif type(value) == "string" then
-			local source = ""
-
-			-- Guarantee the context is unique. This is important because Roblox will not
-			-- allow something with the same source without a differing context value.
-			local context = tableName .. "." .. key
-
-			if localeId == "en" then
-				source = value
-			end
-
-			localizationTable:SetEntryValue(key, source, context, localeId, value)
-		else
-			error("Bad type for value in '" .. key .. "'.")
-		end
-	end
-end
-
---[=[
-	Extracts the locale from the name
-
-	@param name string -- The name to parse
-	@return string -- The locale
-]=]
-function JsonToLocalizationTable.localeFromName(name)
-	if name:sub(-5) == ".json" then
-		return name:sub(1, #name-5)
-	else
-		return name
-	end
-end
-
---[=[
-	Gets or creates the global localization table. If the game isn't running (i.e. test mode), then
-	we'll just not parent it.
-
-	@return string -- The locale
-]=]
-function JsonToLocalizationTable.getOrCreateLocalizationTable()
-	local localizationTableName
-	if RunService:IsServer() then
-		localizationTableName = LOCALIZATION_TABLE_NAME_SERVER
-	else
-		localizationTableName = LOCALIZATION_TABLE_NAME_CLIENT
-	end
-
-	local localizationTable = LocalizationService:FindFirstChild(localizationTableName)
-
-	if not localizationTable then
-		localizationTable = Instance.new("LocalizationTable")
-		localizationTable.Name = localizationTableName
-
-		if RunService:IsRunning() then
-			localizationTable.Parent = LocalizationService
-		end
-	end
-
-	return localizationTable
-end
-
---[=[
-	Loads a folder into a localization table.
-
-	@param tableName string -- Used for source
-	@param folder Folder -- A Roblox folder with StringValues containing JSON, named with the localization in mind
-]=]
-function JsonToLocalizationTable.loadFolder(tableName, folder)
-	assert(type(tableName) == "string", "Bad tableName")
-
-	local localizationTable = JsonToLocalizationTable.getOrCreateLocalizationTable()
-
-	for _, item in pairs(folder:GetDescendants()) do
-		if item:IsA("StringValue") then
-			local localeId = JsonToLocalizationTable.localeFromName(item.Name)
-			JsonToLocalizationTable.addJsonToTable(localizationTable, localeId, item.Value, tableName)
-		elseif item:IsA("ModuleScript") then
-			local localeId = JsonToLocalizationTable.localeFromName(item.Name)
-			recurseAdd(localizationTable, localeId, "", require(item), tableName)
-		end
-	end
-	return localizationTable
-end
-
---[=[
-	Extracts the locale from the folder, or a locale and table.
-
-	@param tableName string -- Used for source
-	@param first Instance | string
-	@param second table?
-	@return LocalizationTable
-]=]
-function JsonToLocalizationTable.toLocalizationTable(tableName, first, second)
-	assert(type(tableName) == "string", "Bad tableName")
-
-	if typeof(first) == "Instance" then
-		local result = JsonToLocalizationTable.loadFolder(tableName, first)
-		-- result.Name = ("JSONTable_%s"):format(first.Name)
-		return result
-	elseif type(first) == "string" and type(second) == "table" then
-		local result = JsonToLocalizationTable.loadTable(tableName, first, second)
-		return result
-	else
-		error("Bad args")
-	end
-end
-
---[=[
-	Extracts the locale from the name
-
-	@param tableName string -- Used for source
-	@param localeId string -- the defaultlocaleId
-	@param dataTable table -- Data table to load from
-	@return LocalizationTable
-]=]
-function JsonToLocalizationTable.loadTable(tableName, localeId, dataTable)
-	assert(type(tableName) == "string", "Bad tableName")
-
-	local localizationTable = JsonToLocalizationTable.getOrCreateLocalizationTable()
-
-	recurseAdd(localizationTable, localeId, "", dataTable, tableName)
-
-	return localizationTable
-end
-
---[=[
-	Adds json to a localization table
-
-	@param localizationTable LocalizationTable -- The localization table to add to
-	@param localeId string -- The localeId to use
-	@param json string -- The json to add with
-	@param tableName string -- Used for source
-]=]
-function JsonToLocalizationTable.addJsonToTable(localizationTable, localeId, json, tableName)
-	assert(type(tableName) == "string", "Bad tableName")
-
-	local decodedTable = HttpService:JSONDecode(json)
-	recurseAdd(localizationTable, localeId, "", decodedTable, tableName)
-end
-
-return JsonToLocalizationTable
-