@lvce-editor/shared-process 0.25.10 → 0.25.11

package/src/parts/ExtensionList/ExtensionList.js

@@ -1,70 +1,64 @@
-import { basename } from 'node:path'
-import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import { VError } from '../VError/VError.js'
-
+import { basename } from 'node:path';
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js';
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import { VError } from '../VError/VError.js';
 const getManifestVersion = (json) => {
-  if (json && json.version && typeof json.version === 'string') {
-    return json.version
-  }
-  return 'n/a'
-}
-
+    if (json && json.version && typeof json.version === 'string') {
+        return json.version;
+    }
+    return 'n/a';
+};
 const getManifestId = (json) => {
-  if (json && json.id && typeof json.id === 'string') {
-    return json.id
-  }
-  return basename(json.path)
-}
-
+    if (json && json.id && typeof json.id === 'string') {
+        return json.id;
+    }
+    return basename(json.path);
+};
 const getSymlink = (json) => {
-  if (json && json.symlink && typeof json.symlink === 'string') {
-    return json.symlink
-  }
-  return ''
-}
-
+    if (json && json.symlink && typeof json.symlink === 'string') {
+        return json.symlink;
+    }
+    return '';
+};
 const getManifestInfo = (json) => {
-  const id = getManifestId(json)
-  const version = getManifestVersion(json)
-  const symlink = getSymlink(json)
-  return {
-    id,
-    version,
-    symlink,
-  }
-}
-
+    const id = getManifestId(json);
+    const version = getManifestVersion(json);
+    const symlink = getSymlink(json);
+    return {
+        id,
+        version,
+        symlink,
+    };
+};
 const isFulfilled = (result) => {
-  return result.status === ExtensionManifestStatus.Resolved
-}
-
+    return result.status === ExtensionManifestStatus.Resolved;
+};
 const getManifestInfos = (manifests) => {
-  const results = manifests.filter(isFulfilled).map(getManifestInfo)
-  return results
-}
-
+    const results = manifests.filter(isFulfilled).map(getManifestInfo);
+    return results;
+};
 export const list = async () => {
-  try {
-    const manifests = await ExtensionManifests.getAll([
-      {
-        type: ExtensionManifestInputType.LinkedExtensionsFolder,
-        path: PlatformPaths.getLinkedExtensionsPath(),
-      },
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getExtensionsPath(),
-      },
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getBuiltinExtensionsPath(),
-      },
-    ])
-    const infos = getManifestInfos(manifests)
-    return infos
-  } catch (error) {
-    throw new VError(error, `Failed to list extensions`)
-  }
-}
+    try {
+        const manifests = await ExtensionManifests.getAll([
+            {
+                type: ExtensionManifestInputType.LinkedExtensionsFolder,
+                path: PlatformPaths.getLinkedExtensionsPath(),
+            },
+            {
+                type: ExtensionManifestInputType.Folder,
+                path: PlatformPaths.getExtensionsPath(),
+            },
+            {
+                type: ExtensionManifestInputType.Folder,
+                path: PlatformPaths.getBuiltinExtensionsPath(),
+            },
+        ]);
+        const infos = getManifestInfos(manifests);
+        return infos;
+    }
+    catch (error) {
+        throw new VError(error, `Failed to list extensions`);
+    }
+};

package/src/parts/ExtensionManagement/ExtensionManagement.ipc.js

@@ -1,19 +1,18 @@
-import * as ExtensionHostIconTheme from '../ExtensionManagement/ExtensionManagementIconTheme.js'
-import * as ExtensionManagement from './ExtensionManagement.js'
-import * as ExtensionHostColorTheme from './ExtensionManagementColorTheme.js'
-import * as ExtensionHostLanguages from './ExtensionManagementLanguages.js'
-
+import * as ExtensionHostIconTheme from '../ExtensionManagement/ExtensionManagementIconTheme.js';
+import * as ExtensionManagement from './ExtensionManagement.js';
+import * as ExtensionHostColorTheme from './ExtensionManagementColorTheme.js';
+import * as ExtensionHostLanguages from './ExtensionManagementLanguages.js';
 // prettier-ignore
 export const Commands = {
-  'ExtensionHost.getColorThemeJson': ExtensionHostColorTheme.getColorThemeJson,
-  'ExtensionHost.getColorThemeNames': ExtensionHostColorTheme.getColorThemeNames,
-  'ExtensionHost.getIconThemeJson': ExtensionHostIconTheme.getIconTheme,
-  'ExtensionHost.getLanguageConfiguration': ExtensionHostLanguages.getLanguageConfiguration,
-  'ExtensionHost.getLanguages': ExtensionHostLanguages.getLanguages,
-  'ExtensionHost.watchColorTheme': ExtensionHostColorTheme.watch,
-  'ExtensionManagement.disable': ExtensionManagement.disable,
-  'ExtensionManagement.enable': ExtensionManagement.enable,
-  'ExtensionManagement.getAllExtensions': ExtensionManagement.getExtensions,
-  'ExtensionManagement.getExtensions': ExtensionManagement.getExtensions,
-  'ExtensionManagement.uninstall': ExtensionManagement.uninstall,
-}
+    'ExtensionHost.getColorThemeJson': ExtensionHostColorTheme.getColorThemeJson,
+    'ExtensionHost.getColorThemeNames': ExtensionHostColorTheme.getColorThemeNames,
+    'ExtensionHost.getIconThemeJson': ExtensionHostIconTheme.getIconTheme,
+    'ExtensionHost.getLanguageConfiguration': ExtensionHostLanguages.getLanguageConfiguration,
+    'ExtensionHost.getLanguages': ExtensionHostLanguages.getLanguages,
+    'ExtensionHost.watchColorTheme': ExtensionHostColorTheme.watch,
+    'ExtensionManagement.disable': ExtensionManagement.disable,
+    'ExtensionManagement.enable': ExtensionManagement.enable,
+    'ExtensionManagement.getAllExtensions': ExtensionManagement.getExtensions,
+    'ExtensionManagement.getExtensions': ExtensionManagement.getExtensions,
+    'ExtensionManagement.uninstall': ExtensionManagement.uninstall,
+};

package/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -1,93 +1,76 @@
-import { mkdir, rename } from 'node:fs/promises'
-import * as Debug from '../Debug/Debug.js'
-import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
-import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import { VError } from '../VError/VError.js'
-
+import { mkdir, rename } from 'node:fs/promises';
+import * as Debug from '../Debug/Debug.js';
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js';
+import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import { VError } from '../VError/VError.js';
 export const enable = async (id) => {
-  try {
-    Debug.debug(`ExtensionManagement#enable ${id}`)
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    const disabledExtensionsPath = PlatformPaths.getDisabledExtensionsPath()
-    await mkdir(extensionsPath, { recursive: true })
-    await rename(Path.join(disabledExtensionsPath, id), Path.join(extensionsPath, id))
-  } catch (error) {
-    throw new VError(error, `Failed to enable extension "${id}"`)
-  }
-}
-
+    try {
+        Debug.debug(`ExtensionManagement#enable ${id}`);
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        const disabledExtensionsPath = PlatformPaths.getDisabledExtensionsPath();
+        await mkdir(extensionsPath, { recursive: true });
+        await rename(Path.join(disabledExtensionsPath, id), Path.join(extensionsPath, id));
+    }
+    catch (error) {
+        throw new VError(error, `Failed to enable extension "${id}"`);
+    }
+};
 export const disable = async (id) => {
-  try {
-    Debug.debug(`ExtensionManagement#disable ${id}`)
-    const disabledExtensionsPath = PlatformPaths.getDisabledExtensionsPath()
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    await mkdir(disabledExtensionsPath, { recursive: true })
-    await rename(Path.join(extensionsPath, id), Path.join(disabledExtensionsPath, id))
-  } catch (error) {
-    throw new VError(error, `Failed to disable extension ${id}`)
-  }
-}
-
+    try {
+        Debug.debug(`ExtensionManagement#disable ${id}`);
+        const disabledExtensionsPath = PlatformPaths.getDisabledExtensionsPath();
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        await mkdir(disabledExtensionsPath, { recursive: true });
+        await rename(Path.join(extensionsPath, id), Path.join(disabledExtensionsPath, id));
+    }
+    catch (error) {
+        throw new VError(error, `Failed to disable extension ${id}`);
+    }
+};
 export const getBuiltinExtensions = () => {
-  return ExtensionManifests.getAll(
-    [
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getBuiltinExtensionsPath(),
-      },
-    ],
-    PlatformPaths.getBuiltinExtensionsPath(),
-  )
-}
-
+    return ExtensionManifests.getAll([
+        {
+            type: ExtensionManifestInputType.Folder,
+            path: PlatformPaths.getBuiltinExtensionsPath(),
+        },
+    ], PlatformPaths.getBuiltinExtensionsPath());
+};
 export const getInstalledExtensions = () => {
-  return ExtensionManifests.getAll(
-    [
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getExtensionsPath(),
-      },
-    ],
-    PlatformPaths.getBuiltinExtensionsPath(),
-  )
-}
-
+    return ExtensionManifests.getAll([
+        {
+            type: ExtensionManifestInputType.Folder,
+            path: PlatformPaths.getExtensionsPath(),
+        },
+    ], PlatformPaths.getBuiltinExtensionsPath());
+};
 export const getExtensions = () => {
-  return ExtensionManifests.getAll(
-    [
-      {
-        type: ExtensionManifestInputType.OnlyExtension,
-        path: PlatformPaths.getOnlyExtensionPath(),
-      },
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getLinkedExtensionsPath(),
-      },
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getExtensionsPath(),
-      },
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getBuiltinExtensionsPath(),
-      },
-    ],
-    PlatformPaths.getBuiltinExtensionsPath(),
-  )
-}
-
+    return ExtensionManifests.getAll([
+        {
+            type: ExtensionManifestInputType.OnlyExtension,
+            path: PlatformPaths.getOnlyExtensionPath(),
+        },
+        {
+            type: ExtensionManifestInputType.Folder,
+            path: PlatformPaths.getLinkedExtensionsPath(),
+        },
+        {
+            type: ExtensionManifestInputType.Folder,
+            path: PlatformPaths.getExtensionsPath(),
+        },
+        {
+            type: ExtensionManifestInputType.Folder,
+            path: PlatformPaths.getBuiltinExtensionsPath(),
+        },
+    ], PlatformPaths.getBuiltinExtensionsPath());
+};
 export const getDisabledExtensions = () => {
-  return ExtensionManifests.getAll(
-    [
-      {
-        type: ExtensionManifestInputType.Folder,
-        path: PlatformPaths.getDisabledExtensionsPath(),
-      },
-    ],
-    PlatformPaths.getBuiltinExtensionsPath(),
-  )
-}
-
-export * from '../ExtensionUninstall/ExtensionUninstall.js'
+    return ExtensionManifests.getAll([
+        {
+            type: ExtensionManifestInputType.Folder,
+            path: PlatformPaths.getDisabledExtensionsPath(),
+        },
+    ], PlatformPaths.getBuiltinExtensionsPath());
+};
+export * from '../ExtensionUninstall/ExtensionUninstall.js';

package/src/parts/ExtensionManagement/ExtensionManagementColorTheme.js

@@ -1,82 +1,74 @@
-import * as Assert from '../Assert/Assert.js'
-import * as FileSystemWatch from '../FileSystemWatch/FileSystemWatch.js'
-import * as ReadJson from '../JsonFile/JsonFile.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-import * as Path from '../Path/Path.js'
-import * as Process from '../Process/Process.js'
-import { VError } from '../VError/VError.js'
-import * as ExtensionManagement from './ExtensionManagement.js'
-
+import * as Assert from '../Assert/Assert.js';
+import * as FileSystemWatch from '../FileSystemWatch/FileSystemWatch.js';
+import * as ReadJson from '../JsonFile/JsonFile.js';
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js';
+import * as Path from '../Path/Path.js';
+import * as Process from '../Process/Process.js';
+import { VError } from '../VError/VError.js';
+import * as ExtensionManagement from './ExtensionManagement.js';
 // TODO test this function
 // TODO very similar with getIconTheme
-
 const getColorThemePath = async (extensions, colorThemeId) => {
-  for (const extension of extensions) {
-    if (!extension.colorThemes) {
-      continue
+    for (const extension of extensions) {
+        if (!extension.colorThemes) {
+            continue;
+        }
+        for (const colorTheme of extension.colorThemes) {
+            if (colorTheme.id !== colorThemeId) {
+                continue;
+            }
+            const absolutePath = Path.join(extension.path, colorTheme.path);
+            return absolutePath;
+        }
     }
-    for (const colorTheme of extension.colorThemes) {
-      if (colorTheme.id !== colorThemeId) {
-        continue
-      }
-      const absolutePath = Path.join(extension.path, colorTheme.path)
-      return absolutePath
-    }
-  }
-  return ''
-}
-
+    return '';
+};
 export const getColorThemeJson = async (colorThemeId) => {
-  Assert.string(colorThemeId)
-  const extensions = await ExtensionManagement.getExtensions()
-  const colorThemePath = await getColorThemePath(extensions, colorThemeId)
-  if (!colorThemePath) {
-    throw new VError(`Color theme "${colorThemeId}" not found in extensions folder`)
-  }
-  try {
-    const json = await ReadJson.readJson(colorThemePath)
-    return json
-  } catch (error) {
-    throw new VError(error, `Failed to load color theme "${colorThemeId}"`)
-  }
-}
-
+    Assert.string(colorThemeId);
+    const extensions = await ExtensionManagement.getExtensions();
+    const colorThemePath = await getColorThemePath(extensions, colorThemeId);
+    if (!colorThemePath) {
+        throw new VError(`Color theme "${colorThemeId}" not found in extensions folder`);
+    }
+    try {
+        const json = await ReadJson.readJson(colorThemePath);
+        return json;
+    }
+    catch (error) {
+        throw new VError(error, `Failed to load color theme "${colorThemeId}"`);
+    }
+};
 const getColorThemeInfo = (extension) => {
-  return extension.colorThemes || []
-}
-
+    return extension.colorThemes || [];
+};
 const getExtensionColorThemeNames = (extension) => {
-  return extension.colorThemes || []
-}
-
+    return extension.colorThemes || [];
+};
 const getColorThemeId = (colorTheme) => {
-  return colorTheme.id
-}
-
+    return colorTheme.id;
+};
 // TODO should send names to renderer worker or names with ids?
 export const getColorThemeNames = async () => {
-  const extensions = await ExtensionManagement.getExtensions()
-  const colorThemes = extensions.flatMap(getExtensionColorThemeNames)
-  const colorThemeNames = colorThemes.map(getColorThemeId)
-  return colorThemeNames
-}
-
+    const extensions = await ExtensionManagement.getExtensions();
+    const colorThemes = extensions.flatMap(getExtensionColorThemeNames);
+    const colorThemeNames = colorThemes.map(getColorThemeId);
+    return colorThemeNames;
+};
 export const getColorThemes = async () => {
-  const extensions = await ExtensionManagement.getExtensions()
-  const colorThemes = extensions.flatMap(getColorThemeInfo)
-  return colorThemes
-}
-
+    const extensions = await ExtensionManagement.getExtensions();
+    const colorThemes = extensions.flatMap(getColorThemeInfo);
+    return colorThemes;
+};
 export const watch = async (socket, colorThemeId) => {
-  // console.log({ socket, colorThemeId })
-  const extensions = await ExtensionManagement.getExtensions()
-  const colorThemePath = await getColorThemePath(extensions, colorThemeId)
-  const verbose = Process.argv.includes('--verbose')
-  if (verbose) {
-    console.info(`[shared-process] starting to watch color theme ${colorThemeId} at ${colorThemePath}`)
-  }
-  const watcher = FileSystemWatch.watchFile(colorThemePath)
-  for await (const event of watcher) {
-    socket.send({ jsonrpc: JsonRpcVersion.Two, method: 'ColorTheme.reload', params: [] })
-  }
-}
+    // console.log({ socket, colorThemeId })
+    const extensions = await ExtensionManagement.getExtensions();
+    const colorThemePath = await getColorThemePath(extensions, colorThemeId);
+    const verbose = Process.argv.includes('--verbose');
+    if (verbose) {
+        console.info(`[shared-process] starting to watch color theme ${colorThemeId} at ${colorThemePath}`);
+    }
+    const watcher = FileSystemWatch.watchFile(colorThemePath);
+    for await (const event of watcher) {
+        socket.send({ jsonrpc: JsonRpcVersion.Two, method: 'ColorTheme.reload', params: [] });
+    }
+};

package/src/parts/ExtensionManagement/ExtensionManagementIconTheme.js

@@ -1,29 +1,29 @@
-import * as ReadJson from '../JsonFile/JsonFile.js'
-import * as Path from '../Path/Path.js'
-import { VError } from '../VError/VError.js'
-import * as ExtensionManagement from './ExtensionManagement.js'
-
+import * as ReadJson from '../JsonFile/JsonFile.js';
+import * as Path from '../Path/Path.js';
+import { VError } from '../VError/VError.js';
+import * as ExtensionManagement from './ExtensionManagement.js';
 export const getIconTheme = async (iconThemeId) => {
-  const extensions = await ExtensionManagement.getExtensions()
-  for (const extension of extensions) {
-    if (!extension.iconThemes) {
-      continue
-    }
-    for (const iconTheme of extension.iconThemes) {
-      if (iconTheme.id !== iconThemeId) {
-        continue
-      }
-      const absolutePath = Path.join(extension.path, iconTheme.path)
-      try {
-        const json = await ReadJson.readJson(absolutePath)
-        return {
-          extensionPath: extension.path,
-          json,
+    const extensions = await ExtensionManagement.getExtensions();
+    for (const extension of extensions) {
+        if (!extension.iconThemes) {
+            continue;
+        }
+        for (const iconTheme of extension.iconThemes) {
+            if (iconTheme.id !== iconThemeId) {
+                continue;
+            }
+            const absolutePath = Path.join(extension.path, iconTheme.path);
+            try {
+                const json = await ReadJson.readJson(absolutePath);
+                return {
+                    extensionPath: extension.path,
+                    json,
+                };
+            }
+            catch (error) {
+                throw new VError(error, `Failed to load icon theme "${iconThemeId}"`);
+            }
         }
-      } catch (error) {
-        throw new VError(error, `Failed to load icon theme "${iconThemeId}"`)
-      }
     }
-  }
-  throw new VError(`Icon theme "${iconThemeId}" not found in extensions folder`)
-}
+    throw new VError(`Icon theme "${iconThemeId}" not found in extensions folder`);
+};

package/src/parts/ExtensionManagement/ExtensionManagementLanguages.js

@@ -1,69 +1,65 @@
 // TODO rename file to languageConfiguration.js
-import { join } from 'node:path'
-import * as GetRemoteUrl from '../GetRemoteUrl/GetRemoteUrl.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-import { VError } from '../VError/VError.js'
-import * as ExtensionManagement from './ExtensionManagement.js'
-
+import { join } from 'node:path';
+import * as GetRemoteUrl from '../GetRemoteUrl/GetRemoteUrl.js';
+import * as JsonFile from '../JsonFile/JsonFile.js';
+import { VError } from '../VError/VError.js';
+import * as ExtensionManagement from './ExtensionManagement.js';
 const getLanguagesFromExtension = (extension) => {
-  // TODO what if extension is null? should not crash process, handle error gracefully
-  if (!extension.languages) {
-    return []
-  }
-  const extensionPath = extension.path
-  const getLanguageFromExtension = (language) => {
-    if (language.tokenize) {
-      if (typeof language.tokenize !== 'string') {
-        console.warn(`[info] ${language.id}: language.tokenize must be of type string but was of type ${typeof language.tokenize}`)
-        return {
-          ...language,
-          extensionPath,
-          tokenize: '',
-        }
-      }
-      return {
-        ...language,
-        extensionPath,
-        tokenize: GetRemoteUrl.getRemoteUrl(join(extensionPath, language.tokenize)),
-      }
+    // TODO what if extension is null? should not crash process, handle error gracefully
+    if (!extension.languages) {
+        return [];
     }
-    return language
-  }
-  return extension.languages.map(getLanguageFromExtension)
-}
-
+    const extensionPath = extension.path;
+    const getLanguageFromExtension = (language) => {
+        if (language.tokenize) {
+            if (typeof language.tokenize !== 'string') {
+                console.warn(`[info] ${language.id}: language.tokenize must be of type string but was of type ${typeof language.tokenize}`);
+                return {
+                    ...language,
+                    extensionPath,
+                    tokenize: '',
+                };
+            }
+            return {
+                ...language,
+                extensionPath,
+                tokenize: GetRemoteUrl.getRemoteUrl(join(extensionPath, language.tokenize)),
+            };
+        }
+        return language;
+    };
+    return extension.languages.map(getLanguageFromExtension);
+};
 const getLanguagesFromExtensions = (extensions) => {
-  return extensions.flatMap(getLanguagesFromExtension)
-}
-
+    return extensions.flatMap(getLanguagesFromExtension);
+};
 export const getLanguages = async () => {
-  const extensions = await ExtensionManagement.getExtensions()
-  const languages = getLanguagesFromExtensions(extensions)
-  return languages
-}
-
+    const extensions = await ExtensionManagement.getExtensions();
+    const languages = getLanguagesFromExtensions(extensions);
+    return languages;
+};
 const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
-  for (const extension of extensions) {
-    if (extension.languages && extension.languages) {
-      for (const language of extension.languages) {
-        if (language.id === languageId && language.configuration) {
-          return join(extension.path, language.configuration)
+    for (const extension of extensions) {
+        if (extension.languages && extension.languages) {
+            for (const language of extension.languages) {
+                if (language.id === languageId && language.configuration) {
+                    return join(extension.path, language.configuration);
+                }
+            }
         }
-      }
     }
-  }
-  return ''
-}
-
+    return '';
+};
 export const getLanguageConfiguration = async (languageId) => {
-  try {
-    const extensions = await ExtensionManagement.getExtensions()
-    const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(extensions, languageId)
-    if (!languageConfigurationPath) {
-      return undefined
+    try {
+        const extensions = await ExtensionManagement.getExtensions();
+        const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(extensions, languageId);
+        if (!languageConfigurationPath) {
+            return undefined;
+        }
+        return await JsonFile.readJson(languageConfigurationPath);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to load language configuration for ${languageId}`);
     }
-    return await JsonFile.readJson(languageConfigurationPath)
-  } catch (error) {
-    throw new VError(error, `Failed to load language configuration for ${languageId}`)
-  }
-}
+};