I made Observer singleton class that subscribe to appropriate events and auto generate JSON object

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using Umbraco.Core;
using Umbraco.Core.Services;
using Umbraco.Web;

namespace WinePortal.Core
{
    public class LocalizationServiceObserver
    {
        public static string ScriptPath { get; private set; }

        public static void Subscribe(string scriptPath)
        {
            ScriptPath = scriptPath;

            LocalizationService.SavedLanguage += UpdateDictionaryScript;
            LocalizationService.DeletedLanguage += UpdateDictionaryScript;
            LocalizationService.DeletedDictionaryItem += UpdateDictionaryScript;
            LocalizationService.SavedDictionaryItem += UpdateDictionaryScript;
        }

        private static void UpdateDictionaryScript(ILocalizationService sender, object e)
        {
            StringBuilder scriptBuilder = new StringBuilder("var UmbDictionary = {\r\n");
            foreach (var language in sender.GetAllLanguages())
            {
                var culture = language.CultureInfo.Name;
                scriptBuilder.AppendLine($"\"{culture}\": [");

                var items = GetDictionaryItems(culture);
                foreach (var dictionaryItem in items)
                {
                    var key = HttpUtility.JavaScriptStringEncode(dictionaryItem.Key);
                    var value = HttpUtility.JavaScriptStringEncode(dictionaryItem.Value);
                    scriptBuilder.AppendLine($"{{ \"Key\": \"{key}\", \"Value\": \"{value}\" }},");
                }

                scriptBuilder.AppendLine("],");
            }
            scriptBuilder.AppendLine("};");
            System.IO.File.WriteAllText(ScriptPath, scriptBuilder.ToString());
        }

        public static IEnumerable<DictionaryItem> GetDictionaryItems(string culture)
        {
            //For now, we're only going to get the English items

            var dictionary = new List<DictionaryItem>();

            var root = ApplicationContext.Current.Services.LocalizationService.GetRootDictionaryItems();

            if (!root.Any())
            {
                return Enumerable.Empty<DictionaryItem>();
            }

            foreach (var item in root)
            {
                dictionary.Add(new DictionaryItem
                {
                    Key = item.ItemKey,
                    Value = item.Translations.Where(x => x.Language.CultureInfo.Name == culture).Select(x => x.Value).FirstOrDefault()
                });

                dictionary.AddRange(LoopThroughDictionaryChildren(item.Key, culture));
            }

            return dictionary;
        }

        private static IEnumerable<DictionaryItem> LoopThroughDictionaryChildren(Guid key, string culture)
        {
            var dictionary = new List<DictionaryItem>();
            var items = ApplicationContext.Current.Services.LocalizationService.GetDictionaryItemChildren(key);

            if (!items.Any())
            {
                return Enumerable.Empty<DictionaryItem>();
            }

            foreach (var subItem in items)
            {
                dictionary.Add(new DictionaryItem
                {
                    Key = subItem.ItemKey,
                    Value = subItem.Translations.Where(x => x.Language.CultureInfo.Name == culture).Select(x => x.Value).FirstOrDefault()
                });

                dictionary.AddRange(LoopThroughDictionaryChildren(subItem.Key, culture));
            }

            return dictionary;
        }
    }



    public class DictionaryItem
    {
        public string Key { get; set; }

        public string Value { get; set; }
    }
}

usage example

protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
        {
            var scriptPath = UmbracoContext.Current.HttpContext.Server.MapPath("~/scripts/UmbDictionary.generated.js");
            LocalizationServiceObserver.Subscribe(scriptPath);
        }

this is more universal approach