added localization caching and removed redundant fromjs calls (#195)

* added localization caching and removed redundant fromjs calls

* Cleanup localization cache implementation

---------

Co-authored-by: Jason Desrosiers <jdesrosi@gmail.com>

Author: animeshsahoo1

src/json-schema-errors.js

@@ -14,9 +14,11 @@ import { Localization } from "./localization.js";
 
 /** @type API.jsonSchemaErrors */
 export const jsonSchemaErrors = async (errorOutput, schemaUri, instance, options = {}) => {
-  const normalizedErrors = await normalizedOutput(instance, errorOutput, schemaUri);
   const rootInstance = Instance.fromJs(instance);
-  const localization = await Localization.forLocale(options.locale ?? "en-US");
+  const [normalizedErrors, localization] = await Promise.all([
+    normalizedOutput(rootInstance, errorOutput, schemaUri),
+    Localization.forLocale(options.locale ?? "en-US")
+  ]);
   return await getErrors(normalizedErrors, rootInstance, localization);
 };
 
@@ -28,12 +30,11 @@ export const setNormalizationHandler = (schemaUri, handler) => {
   normalizationHandlers[schemaUri] = handler;
 };
 
-/** @type (instance: API.Json, errorOutput: API.OutputUnit, subjectUri: string) => Promise<API.NormalizedOutput> */
-async function normalizedOutput(instance, errorOutput, subjectUri) {
+/** @type (value: JsonNode, errorOutput: API.OutputUnit, subjectUri: string) => Promise<API.NormalizedOutput> */
+async function normalizedOutput(value, errorOutput, subjectUri) {
   const schema = await getSchema(subjectUri);
   const errorIndex = await constructErrorIndex(errorOutput, schema);
   const { schemaUri, ast } = await compile(schema);
-  const value = Instance.fromJs(instance);
   return evaluateSchema(schemaUri, value, { ast, errorIndex, plugins: [...ast.plugins] });
 }
 

src/localization.js

@@ -6,6 +6,9 @@ import { FluentBundle, FluentResource } from "@fluent/bundle";
  * @import { ContainsRange, Json } from "./index.d.ts"
  */
 
+/** @type Map<string, Localization> */
+const localizationCache = new Map();
+
 export class Localization {
   /**
    * @param {string} locale
@@ -20,16 +23,19 @@ export class Localization {
 
   /** @type (locale: string) => Promise<Localization> */
   static async forLocale(locale) {
-    try {
-      const ftl = await readFile(`${import.meta.dirname}/translations/${locale}.ftl`, "utf-8");
-      const resource = new FluentResource(ftl);
-      const bundle = new FluentBundle(locale);
-      bundle.addResource(resource);
-
-      return new Localization(locale, bundle);
-    } catch (error) {
-      throw Error(`The ${locale} locale is not supported.`, { cause: error });
+    if (!localizationCache.has(locale)) {
+      try {
+        const ftl = await readFile(`${import.meta.dirname}/translations/${locale}.ftl`, "utf-8");
+        const resource = new FluentResource(ftl);
+        const bundle = new FluentBundle(locale);
+        bundle.addResource(resource);
+        localizationCache.set(locale, new Localization(locale, bundle));
+      } catch (error) {
+        throw Error(`The ${locale} locale is not supported.`, { cause: error });
+      }
     }
+
+    return /** @type Localization */ (localizationCache.get(locale));
   }
 
   /** @type (messageId: string, args: Record<string, FluentVariable>) => string */