@lang-tag/cli 0.13.1 → 0.15.0

package/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { program } from "commander";
 import fs, { readFileSync, existsSync } from "fs";
-import { writeFile, mkdir, readFile, rm } from "fs/promises";
+import { writeFile, readFile } from "fs/promises";
 import JSON5 from "json5";
 import * as path from "path";
-import path__default, { sep, dirname, resolve as resolve$1, join } from "path";
+import path__default, { sep, join, dirname as dirname$1 } from "path";
 import { globby } from "globby";
-import path$1, { resolve, dirname as dirname$1 } from "pathe";
+import path$1, { resolve, dirname } from "pathe";
 import { pathToFileURL, fileURLToPath } from "url";
+import { N as NamespaceCollector, $ as $LT_ReadFileContent, a as $LT_ReadJSON, b as $LT_WriteJSON, c as $LT_EnsureDirectoryExists, d as $LT_WriteFileWithDirs } from "./namespace-collector-DCruv_PK.js";
 import * as process$1 from "node:process";
 import process__default from "node:process";
 import * as acorn from "acorn";
@@ -60,31 +61,33 @@ class $LT_TagProcessor {
         while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
           i++;
         }
-        if (i >= fileContent.length || fileContent[i] !== "{") {
-          currentIndex = matchStartIndex + 1;
-          continue;
-        }
-        braceCount = 1;
-        const secondParamStart = i;
-        i++;
-        while (i < fileContent.length && braceCount > 0) {
-          if (fileContent[i] === "{") braceCount++;
-          if (fileContent[i] === "}") braceCount--;
-          i++;
-        }
-        if (braceCount !== 0) {
-          currentIndex = matchStartIndex + 1;
-          continue;
-        }
-        parameter2Text = fileContent.substring(secondParamStart, i);
-        while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
-          i++;
-        }
-        if (i < fileContent.length && fileContent[i] === ",") {
+        if (i >= fileContent.length || fileContent[i] === ")") ;
+        else if (fileContent[i] === "{") {
+          braceCount = 1;
+          const secondParamStart = i;
           i++;
+          while (i < fileContent.length && braceCount > 0) {
+            if (fileContent[i] === "{") braceCount++;
+            if (fileContent[i] === "}") braceCount--;
+            i++;
+          }
+          if (braceCount !== 0) {
+            currentIndex = matchStartIndex + 1;
+            continue;
+          }
+          parameter2Text = fileContent.substring(secondParamStart, i);
           while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
             i++;
           }
+          if (i < fileContent.length && fileContent[i] === ",") {
+            i++;
+            while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
+              i++;
+            }
+          }
+        } else {
+          currentIndex = matchStartIndex + 1;
+          continue;
         }
       } else if (fileContent[i] !== ")") {
         currentIndex = matchStartIndex + 1;
@@ -479,10 +482,13 @@ const CONFIG_FILE_NAME = ".lang-tag.config.js";
 const EXPORTS_FILE_NAME = ".lang-tag.exports.json";
 const LANG_TAG_DEFAULT_CONFIG = {
   tagName: "lang",
+  isLibrary: false,
   includes: ["src/**/*.{js,ts,jsx,tsx}"],
   excludes: ["node_modules", "dist", "build"],
-  outputDir: "locales/en",
+  localesDirectory: "locales",
+  baseLanguageCode: "en",
   collect: {
+    collector: new NamespaceCollector(),
     defaultNamespace: "common",
     ignoreConflictsWithMatchingValues: true,
     onCollectConfigFix: ({ config, langTagConfig }) => {
@@ -509,8 +515,6 @@ const LANG_TAG_DEFAULT_CONFIG = {
       actions.setExportName(`translations${exportIndex}`);
     }
   },
-  isLibrary: false,
-  language: "en",
   translationArgPosition: 1,
   onConfigGeneration: async (event) => {
   }
@@ -527,10 +531,10 @@ async function $LT_ReadConfig(projectPath) {
     }
     const userConfig = configModule.default || {};
     const tn = (userConfig.tagName || "").toLowerCase().replace(/[-_\s]/g, "");
-    if (tn.includes("langtag")) {
-      throw new Error('Custom tagName cannot include "langtag"! (It is not recommended for use with libraries)\n');
+    if (tn === "langtag" || tn === "lang-tag") {
+      throw new Error('Custom tagName cannot be "lang-tag" or "langtag"! (It is not recommended for use with libraries)\n');
     }
-    return {
+    const config = {
       ...LANG_TAG_DEFAULT_CONFIG,
       ...userConfig,
       import: {
@@ -542,39 +546,14 @@ async function $LT_ReadConfig(projectPath) {
         ...userConfig.collect
       }
     };
+    if (!config.collect.collector) {
+      throw new Error("Collector not found! (config.collect.collector)");
+    }
+    return config;
   } catch (error) {
     throw error;
   }
 }
-async function $LT_EnsureDirectoryExists(filePath) {
-  await mkdir(filePath, { recursive: true });
-}
-async function $LT_RemoveDirectory(dirPath) {
-  try {
-    await rm(dirPath, { recursive: true, force: true });
-  } catch (error) {
-  }
-}
-async function $LT_WriteJSON(filePath, data) {
-  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-}
-async function $LT_ReadJSON(filePath) {
-  const content = await readFile(filePath, "utf-8");
-  return JSON.parse(content);
-}
-async function $LT_WriteFileWithDirs(filePath, content) {
-  const dir = dirname(filePath);
-  try {
-    await mkdir(dir, { recursive: true });
-  } catch (error) {
-  }
-  await writeFile(filePath, content, "utf-8");
-}
-async function $LT_ReadFileContent(relativeFilePath) {
-  const cwd = process.cwd();
-  const absolutePath = resolve$1(cwd, relativeFilePath);
-  return await readFile(absolutePath, "utf-8");
-}
 function parseObjectAST(code) {
   const nodes = [];
   try {
@@ -976,6 +955,8 @@ function $LT_CreateDefaultLogger(debugMode, translationArgPosition = 1) {
 async function $LT_GetCommandEssentials() {
   const config = await $LT_ReadConfig(process__default.cwd());
   const logger = $LT_CreateDefaultLogger(config.debug, config.translationArgPosition);
+  config.collect.collector.config = config;
+  config.collect.collector.logger = logger;
   return {
     config,
     logger
@@ -1038,36 +1019,26 @@ function deepMergeTranslations(target, source) {
   }
   return changed;
 }
-async function $LT_WriteToNamespaces({ config, namespaces, logger, clean }) {
-  const changedNamespaces = [];
-  if (clean) {
-    logger.info("Cleaning output directory...");
-    await $LT_RemoveDirectory(config.outputDir);
-  }
-  await $LT_EnsureDirectoryExists(config.outputDir);
-  for (let namespace of Object.keys(namespaces)) {
+async function $LT_WriteToCollections({ config, collections, logger, clean }) {
+  await config.collect.collector.preWrite(clean);
+  const changedCollections = [];
+  for (let namespace of Object.keys(collections)) {
     if (!namespace) {
       continue;
     }
-    const filePath = resolve(
-      process__default.cwd(),
-      config.outputDir,
-      namespace + ".json"
-    );
+    const filePath = await config.collect.collector.resolveCollectionFilePath(namespace);
     let originalJSON = {};
     try {
       originalJSON = await $LT_ReadJSON(filePath);
     } catch (e) {
-      if (!clean) {
-        logger.warn(`Original namespace file "{namespace}.json" not found. A new one will be created.`, { namespace });
-      }
+      await config.collect.collector.onMissingCollection(namespace);
     }
-    if (deepMergeTranslations(originalJSON, namespaces[namespace])) {
-      changedNamespaces.push(namespace);
+    if (deepMergeTranslations(originalJSON, collections[namespace])) {
+      changedCollections.push(namespace);
       await $LT_WriteJSON(filePath, originalJSON);
     }
   }
-  return changedNamespaces;
+  await config.collect.collector.postWrite(changedCollections);
 }
 async function $LT_CollectCandidateFilesWithTags(props) {
   const { config, logger } = props;
@@ -1119,30 +1090,32 @@ async function $LT_WriteAsExportFile({ config, logger, files }) {
     };
   }
   const data = {
-    language: config.language,
+    language: config.baseLanguageCode,
     packageName: packageJson.name || "",
     files: langTagFiles
   };
   await $LT_WriteJSON(EXPORTS_FILE_NAME, data);
   logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
 }
-async function $LT_GroupTagsToNamespaces({ logger, files, config }) {
+async function $LT_GroupTagsToCollections({ logger, files, config }) {
   let totalTags = 0;
-  const namespaces = {};
-  function getTranslations(namespace) {
-    const namespaceTranslations = namespaces[namespace] || {};
-    if (!(namespace in namespaces)) {
-      namespaces[namespace] = namespaceTranslations;
+  const collections = {};
+  function getTranslationsCollection(namespace) {
+    const collectionName = config.collect.collector.aggregateCollection(namespace);
+    const collection = collections[collectionName] || {};
+    if (!(collectionName in collections)) {
+      collections[collectionName] = collection;
     }
-    return namespaceTranslations;
+    return collection;
   }
   const allConflicts = [];
   const existingValuesByNamespace = /* @__PURE__ */ new Map();
   for (const file of files) {
     totalTags += file.tags.length;
-    for (const tag of file.tags) {
+    for (const _tag of file.tags) {
+      const tag = config.collect.collector.transformTag(_tag);
       const tagConfig = tag.parameterConfig;
-      const namespaceTranslations = getTranslations(tagConfig.namespace);
+      const collection = getTranslationsCollection(tagConfig.namespace);
       let existingValues = existingValuesByNamespace.get(tagConfig.namespace);
       if (!existingValues) {
         existingValues = /* @__PURE__ */ new Map();
@@ -1185,7 +1158,7 @@ async function $LT_GroupTagsToNamespaces({ logger, files, config }) {
       };
       const target = await ensureNestedObject(
         tagConfig.path,
-        namespaceTranslations,
+        collection,
         valueTracker,
         addConflict
       );
@@ -1205,7 +1178,7 @@ async function $LT_GroupTagsToNamespaces({ logger, files, config }) {
     let shouldContinue = true;
     config.collect.onCollectFinish({
       totalTags,
-      namespaces,
+      namespaces: collections,
       conflicts: allConflicts,
       logger,
       exit() {
@@ -1216,11 +1189,11 @@ async function $LT_GroupTagsToNamespaces({ logger, files, config }) {
       throw new Error(`LangTagConflictResolution:Processing stopped due to collect finish handler`);
     }
   }
-  return namespaces;
+  return collections;
 }
-async function ensureNestedObject(path2, root, valueTracker, addConflict) {
-  if (!path2 || !path2.trim()) return root;
-  let current = root;
+async function ensureNestedObject(path2, rootCollection, valueTracker, addConflict) {
+  if (!path2 || !path2.trim()) return rootCollection;
+  let current = rootCollection;
   let currentPath = "";
   for (const key of path2.split(".")) {
     currentPath = currentPath ? `${currentPath}.${key}` : key;
@@ -1320,19 +1293,10 @@ async function $LT_CMD_Collect(options) {
     return;
   }
   try {
-    const namespaces = await $LT_GroupTagsToNamespaces({ logger, files, config });
+    const collections = await $LT_GroupTagsToCollections({ logger, files, config });
     const totalTags = files.reduce((sum, file) => sum + file.tags.length, 0);
     logger.debug("Found {totalTags} translation tags", { totalTags });
-    const changedNamespaces = await $LT_WriteToNamespaces({ config, namespaces, logger, clean: options?.clean });
-    if (!changedNamespaces?.length) {
-      logger.info("No changes were made based on the current configuration and files");
-      return;
-    }
-    const n = changedNamespaces.map((n2) => `"${n2}.json"`).join(", ");
-    logger.success("Updated namespaces {outputDir} ({namespaces})", {
-      outputDir: config.outputDir,
-      namespaces: n
-    });
+    await $LT_WriteToCollections({ config, collections, logger, clean: options?.clean });
   } catch (e) {
     const prefix = "LangTagConflictResolution:";
     if (e.message.startsWith(prefix)) {
@@ -1398,15 +1362,8 @@ async function handleFile(config, logger, cwdRelativeFilePath, event) {
   const absoluteFilePath = path__default.join(cwd, cwdRelativeFilePath);
   await checkAndRegenerateFileLangTags(config, logger, absoluteFilePath, cwdRelativeFilePath);
   const files = await $LT_CollectCandidateFilesWithTags({ filesToScan: [cwdRelativeFilePath], config, logger });
-  const namespaces = await $LT_GroupTagsToNamespaces({ logger, files, config });
-  const changedNamespaces = await $LT_WriteToNamespaces({ config, namespaces, logger });
-  if (changedNamespaces.length > 0) {
-    const n = changedNamespaces.map((n2) => `"${n2}.json"`).join(", ");
-    logger.success("Updated namespaces {outputDir} ({namespaces})", {
-      outputDir: config.outputDir,
-      namespaces: n
-    });
-  }
+  const namespaces = await $LT_GroupTagsToCollections({ logger, files, config });
+  await $LT_WriteToCollections({ config, collections: namespaces, logger });
 }
 async function detectModuleSystem() {
   const packageJsonPath = join(process.cwd(), "package.json");
@@ -1446,7 +1403,13 @@ const generationAlgorithm = pathBasedConfigGenerator({
     //         },
     //         admin: {
     //             '>': 'management', // rename "admin" to "management"
-    //             users: false       // ignore "users"
+    //             users: false       // ignore "users",
+    //             ui: {
+    //                 '>>': {        // 'redirect' - ignore everything, jump to 'ui' namespace and prefix all paths with 'admin'
+    //                     namespace: 'ui',
+    //                     pathPrefix: 'admin'
+    //                 }
+    //             }
     //         }
     //     }
     // }
@@ -1459,7 +1422,8 @@ const config = {
     isLibrary: false,
     includes: ['src/**/*.{js,ts,jsx,tsx}'],
     excludes: ['node_modules', 'dist', 'build', '**/*.test.ts'],
-    outputDir: 'public/locales/en',
+    localesDirectory: 'public/locales',
+    baseLanguageCode: 'en',
     onConfigGeneration: async event => {
         // We do not modify imported configurations
         if (event.isImportedLibrary) return;
@@ -1588,7 +1552,7 @@ async function $LT_ImportLibraries(config, logger) {
     const content = `${config.import.tagImportPath}
 
 ${exports}`;
-    await $LT_EnsureDirectoryExists(dirname$1(filePath));
+    await $LT_EnsureDirectoryExists(dirname(filePath));
     await writeFile(filePath, content, "utf-8");
     logger.success('Imported node_modules file: "{fileName}"', { fileName });
   }
@@ -1606,7 +1570,7 @@ function renderTemplate(template, data) {
 }
 function loadTemplate(templateName) {
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
+  const __dirname = dirname$1(__filename);
   const templatePath = join(__dirname, "template", `${templateName}.mustache`);
   try {
     return readFileSync(templatePath, "utf-8");

package/namespace-collector-DCruv_PK.js

@@ -0,0 +1,95 @@
+import { mkdir, writeFile, readFile, rm } from "fs/promises";
+import { dirname, resolve } from "path";
+import path, { resolve as resolve$1 } from "pathe";
+import process__default from "node:process";
+class TranslationsCollector {
+  config;
+  logger;
+}
+async function $LT_EnsureDirectoryExists(filePath) {
+  await mkdir(filePath, { recursive: true });
+}
+async function $LT_RemoveDirectory(dirPath) {
+  try {
+    await rm(dirPath, { recursive: true, force: true });
+  } catch (error) {
+  }
+}
+async function $LT_RemoveFile(filePath) {
+  try {
+    await rm(filePath, { force: true });
+  } catch (error) {
+  }
+}
+async function $LT_WriteJSON(filePath, data) {
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function $LT_ReadJSON(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function $LT_WriteFileWithDirs(filePath, content) {
+  const dir = dirname(filePath);
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (error) {
+  }
+  await writeFile(filePath, content, "utf-8");
+}
+async function $LT_ReadFileContent(relativeFilePath) {
+  const cwd = process.cwd();
+  const absolutePath = resolve(cwd, relativeFilePath);
+  return await readFile(absolutePath, "utf-8");
+}
+class NamespaceCollector extends TranslationsCollector {
+  clean;
+  languageDirectory;
+  aggregateCollection(namespace) {
+    return namespace;
+  }
+  transformTag(tag) {
+    return tag;
+  }
+  async preWrite(clean) {
+    this.clean = clean;
+    this.languageDirectory = path.join(this.config.localesDirectory, this.config.baseLanguageCode);
+    if (clean) {
+      this.logger.info("Cleaning output directory...");
+      await $LT_RemoveDirectory(this.languageDirectory);
+    }
+    await $LT_EnsureDirectoryExists(this.languageDirectory);
+  }
+  async resolveCollectionFilePath(collectionName) {
+    return resolve$1(
+      process__default.cwd(),
+      this.languageDirectory,
+      collectionName + ".json"
+    );
+  }
+  async onMissingCollection(collectionName) {
+    if (!this.clean) {
+      this.logger.warn(`Original namespace file "{namespace}.json" not found. A new one will be created.`, { namespace: collectionName });
+    }
+  }
+  async postWrite(changedCollections) {
+    if (!changedCollections?.length) {
+      this.logger.info("No changes were made based on the current configuration and files");
+      return;
+    }
+    const n = changedCollections.map((n2) => `"${n2}.json"`).join(", ");
+    this.logger.success("Updated namespaces {outputDir} ({namespaces})", {
+      outputDir: this.config.localesDirectory,
+      namespaces: n
+    });
+  }
+}
+export {
+  $LT_ReadFileContent as $,
+  NamespaceCollector as N,
+  TranslationsCollector as T,
+  $LT_ReadJSON as a,
+  $LT_WriteJSON as b,
+  $LT_EnsureDirectoryExists as c,
+  $LT_WriteFileWithDirs as d,
+  $LT_RemoveFile as e
+};

package/namespace-collector-DRnZvkDR.cjs

@@ -0,0 +1,94 @@
+"use strict";
+const promises = require("fs/promises");
+const path = require("path");
+const path$1 = require("pathe");
+const process$1 = require("node:process");
+class TranslationsCollector {
+  config;
+  logger;
+}
+async function $LT_EnsureDirectoryExists(filePath) {
+  await promises.mkdir(filePath, { recursive: true });
+}
+async function $LT_RemoveDirectory(dirPath) {
+  try {
+    await promises.rm(dirPath, { recursive: true, force: true });
+  } catch (error) {
+  }
+}
+async function $LT_RemoveFile(filePath) {
+  try {
+    await promises.rm(filePath, { force: true });
+  } catch (error) {
+  }
+}
+async function $LT_WriteJSON(filePath, data) {
+  await promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function $LT_ReadJSON(filePath) {
+  const content = await promises.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function $LT_WriteFileWithDirs(filePath, content) {
+  const dir = path.dirname(filePath);
+  try {
+    await promises.mkdir(dir, { recursive: true });
+  } catch (error) {
+  }
+  await promises.writeFile(filePath, content, "utf-8");
+}
+async function $LT_ReadFileContent(relativeFilePath) {
+  const cwd = process.cwd();
+  const absolutePath = path.resolve(cwd, relativeFilePath);
+  return await promises.readFile(absolutePath, "utf-8");
+}
+class NamespaceCollector extends TranslationsCollector {
+  clean;
+  languageDirectory;
+  aggregateCollection(namespace) {
+    return namespace;
+  }
+  transformTag(tag) {
+    return tag;
+  }
+  async preWrite(clean) {
+    this.clean = clean;
+    this.languageDirectory = path$1.join(this.config.localesDirectory, this.config.baseLanguageCode);
+    if (clean) {
+      this.logger.info("Cleaning output directory...");
+      await $LT_RemoveDirectory(this.languageDirectory);
+    }
+    await $LT_EnsureDirectoryExists(this.languageDirectory);
+  }
+  async resolveCollectionFilePath(collectionName) {
+    return path$1.resolve(
+      process$1.cwd(),
+      this.languageDirectory,
+      collectionName + ".json"
+    );
+  }
+  async onMissingCollection(collectionName) {
+    if (!this.clean) {
+      this.logger.warn(`Original namespace file "{namespace}.json" not found. A new one will be created.`, { namespace: collectionName });
+    }
+  }
+  async postWrite(changedCollections) {
+    if (!changedCollections?.length) {
+      this.logger.info("No changes were made based on the current configuration and files");
+      return;
+    }
+    const n = changedCollections.map((n2) => `"${n2}.json"`).join(", ");
+    this.logger.success("Updated namespaces {outputDir} ({namespaces})", {
+      outputDir: this.config.localesDirectory,
+      namespaces: n
+    });
+  }
+}
+exports.$LT_EnsureDirectoryExists = $LT_EnsureDirectoryExists;
+exports.$LT_ReadFileContent = $LT_ReadFileContent;
+exports.$LT_ReadJSON = $LT_ReadJSON;
+exports.$LT_RemoveFile = $LT_RemoveFile;
+exports.$LT_WriteFileWithDirs = $LT_WriteFileWithDirs;
+exports.$LT_WriteJSON = $LT_WriteJSON;
+exports.NamespaceCollector = NamespaceCollector;
+exports.TranslationsCollector = TranslationsCollector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lang-tag/cli",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/template/base-app.mustache

@@ -33,7 +33,6 @@ export function {{tagName}}{{#isTypeScript}}<T extends LangTagTranslations>{{/is
     //         transform: ({ path, params }) => t(path, params),
     //     });
     // };
-    // 
     // // SSR
     // const initT = async (language?: string) => {
     //     const { t } = await initTranslations({ language, namespaces: [namespace] });
@@ -51,22 +50,18 @@ export function {{tagName}}{{#isTypeScript}}<T extends LangTagTranslations>{{/is
         });
     };
 
-    const client = () => {
-        {{#isReact}}
-        return useMemo(() => createTranslations(), []);
-        {{/isReact}}
-        {{^isReact}}
-        return createTranslations();
-        {{/isReact}}
-    };
-
-    const server = () => {
-        return createTranslations();
-    };
-
     return {
-        client,
-        server,
+        client: () => {
+            {{#isReact}}
+            return useMemo(() => createTranslations(), []);
+            {{/isReact}}
+            {{^isReact}}
+            return createTranslations();
+            {{/isReact}}
+        },
+        server: () => {
+            return createTranslations();
+        },
         {{#isTypeScript}}
         Type: {} as CallableTranslations<T>,
         {{/isTypeScript}}

package/template/base-library.mustache

@@ -40,45 +40,36 @@ export function {{tagName}}<T extends LangTagTranslations>(
 
     {{#isReact}}
     const Context = createContext{{#isTypeScript}}<CallableTranslations<T> | null>{{/isTypeScript}}(null);
-
-    const useTranslations = () => {
-        const contextTranslations = useContext(Context);
-        return useMemo(() => createTranslationHelper(contextTranslations), [contextTranslations]);
-    };
-
-    const initTranslations = (translations{{#isTypeScript}}?: PartialFlexibleTranslations<T>{{/isTypeScript}}) => {
-        const normalized = useMemo(
-            () => translations ? normalizeTranslations(translations) : null,
-            [translations]
-        );
-
-        return useMemo(() => createTranslationHelper(normalized), [normalized]);
-    };
-
-    function Provider({translations, children}{{#isTypeScript}}: { translations?: PartialFlexibleTranslations<T>; children: ReactNode }{{/isTypeScript}}){{#isTypeScript}}: ReactNode{{/isTypeScript}} {
-        const normalized = useMemo(
-            () => translations ? normalizeTranslations(translations) : null,
-            [translations]
-        );
-
-        return <Context.Provider value={normalized}>{children}</Context.Provider>;
-    }
-    {{/isReact}}
-    {{^isReact}}
-    const initTranslations = (translations{{#isTypeScript}}?: PartialFlexibleTranslations<T>{{/isTypeScript}}) => {
-        const normalized = translations ? normalizeTranslations(translations) : null;
-        return createTranslationHelper(normalized);
-    };
     {{/isReact}}
 
     return {
         {{#isReact}}
-        useTranslations,
-        initTranslations,
-        Provider,
+        useTranslations: () => {
+            const contextTranslations = useContext(Context);
+            return useMemo(() => createTranslationHelper(contextTranslations), [contextTranslations]);
+        },
+        initTranslations: (translations{{#isTypeScript}}?: PartialFlexibleTranslations<T>{{/isTypeScript}}) => {
+            const normalized = useMemo(
+                () => translations ? normalizeTranslations(translations) : null,
+                [translations]
+            );
+
+            return useMemo(() => createTranslationHelper(normalized), [normalized]);
+        },
+        Provider({translations, children}{{#isTypeScript}}: { translations?: PartialFlexibleTranslations<T>; children: ReactNode }{{/isTypeScript}}){{#isTypeScript}}: ReactNode{{/isTypeScript}} {
+            const normalized = useMemo(
+                () => translations ? normalizeTranslations(translations) : null,
+                [translations]
+            );
+
+            return <Context.Provider value={normalized}>{children}</Context.Provider>;
+        },
         {{/isReact}}
         {{^isReact}}
-        initTranslations,
+        initTranslations: (translations{{#isTypeScript}}?: PartialFlexibleTranslations<T>{{/isTypeScript}}) => {
+            const normalized = translations ? normalizeTranslations(translations) : null;
+            return createTranslationHelper(normalized);
+        };,
         {{/isReact}}
         {{#isTypeScript}}
         InputType: {} as PartialFlexibleTranslations<T>,