@nimpl/i18n 1.1.0

package/ClientTranslation.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type I18nOptions } from './types';
+type ClientTranslationProps = {
+    term: string;
+    components?: {
+        [key: string]: JSX.Element;
+    };
+    query?: I18nOptions['query'];
+    removeUnusedQueries?: I18nOptions['removeUnusedQueries'];
+};
+declare const ClientTranslation: React.FC<ClientTranslationProps>;
+export default ClientTranslation;

package/I18nProvider.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type I18nTransmitterProps } from './I18nTransmitter';
+type I18nProviderProps = {
+    lang: string;
+    children: React.ReactNode;
+    clientTerms?: I18nTransmitterProps['terms'];
+};
+declare const I18nProvider: React.FC<I18nProviderProps>;
+export default I18nProvider;

package/I18nTransmitter.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { type I18nOptions } from './types';
+export type I18nTransmitterProps = {
+    terms: (string | [string, I18nOptions])[];
+    children: React.ReactNode;
+    cleanThread?: boolean;
+};
+declare const I18nTransmitter: React.FC<I18nTransmitterProps>;
+export default I18nTransmitter;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexander Savelyev <vordgi1@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @nimpl/i18n
+
+i18n library designed primarily with server components in mind and maximum optimization (due to the transfer of logic to the assembly stage and/or server side).
+
+## Why one more library?
+
+Server components are a recent feature in React. Existing translation libraries are not yet well-optimized for them. If they support it, then only by disabling Next.js static optimization.
+
+This library is an attempt to create a highly optimized solution exclusively using the current capabilities of React.js, Next.js and node.js.
+
+## Features
+
+Support for loading translations during page rendering (*instead of the application build step*), allowing for up-to-date translations with ISR or SSR;
+
+Support for revalidation logic, i.e. you can specify how often translations should be updated (*or that they should not be updated at all*);
+
+Optimized caching system - not a single extra request will be sent, even with parallel building (which is now enabled by default);
+
+Passing only those translations to the client that are needed on the client;
+
+Embedding parameters in client translations on the server;
+
+Support for html entities.
+
+## Installation
+
+**Using npm:**
+
+```bash
+npm i @nimpl/i18n
+```
+
+**Using yarn:**
+
+```bash
+yarn add @nimpl/i18n
+```
+
+## Additionally
+
+Create tasks with wishes, ideas, difficulties, etc. All of them will definitely be considered and thought over.
+
+## License
+
+[MIT](https://github.com/vordgi/nimpl-i18n/blob/main/LICENSE)

package/ServerTranslation.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type I18nOptions } from './types';
+type ServerTranslationProps = {
+    term: string;
+    components?: {
+        [key: string]: JSX.Element;
+    };
+    query?: I18nOptions['query'];
+    removeUnusedQueries?: I18nOptions['removeUnusedQueries'];
+};
+declare const ServerTranslation: React.FC<ServerTranslationProps>;
+export default ServerTranslation;

package/createTranslation.d.ts

@@ -0,0 +1,7 @@
+import { type I18nOptions } from './types';
+type CreateTranslationReturnType = {
+    t: (term: string, opts?: I18nOptions) => string;
+    lang: string;
+};
+declare const createTranslation: (lang: string, namespace?: string) => Promise<CreateTranslationReturnType>;
+export default createTranslation;

package/dist/ClientTranslation.js

@@ -0,0 +1,15 @@
+"use strict";
+'use client';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Translation_1 = __importDefault(require("./lib/Translation"));
+const useTranslation_1 = __importDefault(require("./useTranslation"));
+const ClientTranslation = ({ term, components, query, removeUnusedQueries }) => {
+    const { t } = (0, useTranslation_1.default)();
+    const text = t(term, { query, removeUnusedQueries });
+    return (react_1.default.createElement(Translation_1.default, { term: term, text: text, components: components }));
+};
+exports.default = ClientTranslation;

package/dist/I18nProvider.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const I18nContext_1 = require("./lib/I18nContext");
+const I18nTransmitter_1 = __importDefault(require("./I18nTransmitter"));
+const getDictionary_1 = __importDefault(require("./lib/getDictionary"));
+const I18nProvider = async ({ children, lang, clientTerms = [] }) => {
+    const dictionary = await (0, getDictionary_1.default)(lang);
+    return (react_1.default.createElement(I18nContext_1.I18nContext.Provider, { value: { lang, dictionary } },
+        react_1.default.createElement(I18nTransmitter_1.default, { terms: clientTerms, cleanThread: true }, children)));
+};
+exports.default = I18nProvider;

package/dist/I18nTransmitter.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const object_path_1 = __importDefault(require("object-path"));
+const get_server_context_1 = __importDefault(require("next-impl-getters/get-server-context"));
+const I18nContext_1 = require("./lib/I18nContext");
+const ClientI18nProvider_1 = __importDefault(require("./lib/ClientI18nProvider"));
+const formatServerTranslate_1 = __importDefault(require("./lib/formatServerTranslate"));
+const formatServerTranslates = (result, targetKey, translates, opts = {}) => {
+    if (!translates)
+        return;
+    if (typeof translates === 'string') {
+        // eslint-disable-next-line no-param-reassign
+        result[targetKey] = (0, formatServerTranslate_1.default)({ term: targetKey, text: translates, parseEntities: true, ...opts });
+    }
+    else {
+        Object.entries(translates).forEach(([subKey, translate]) => {
+            formatServerTranslates(result, `${targetKey}.${subKey}`, translate, opts);
+        });
+    }
+};
+const I18nTransmitter = async ({ terms, children, cleanThread }) => {
+    const context = (0, get_server_context_1.default)(I18nContext_1.I18nContext);
+    if (!context) {
+        throw new Error('Please, Init I18nProvider - https://github.com/vordgi/nimpl-i18n#server-components');
+    }
+    const { dictionary, lang } = context;
+    const result = {};
+    terms.forEach((term) => {
+        if (Array.isArray(term)) {
+            const [termKey, opts] = term;
+            const translates = object_path_1.default.get(dictionary, termKey);
+            formatServerTranslates(result, termKey, translates, opts);
+        }
+        else {
+            const translates = object_path_1.default.get(dictionary, term);
+            formatServerTranslates(result, term, translates);
+        }
+    });
+    return (react_1.default.createElement(ClientI18nProvider_1.default, { lang: lang, translates: result, cleanThread: cleanThread }, children));
+};
+exports.default = I18nTransmitter;

package/dist/ServerTranslation.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Translation_1 = __importDefault(require("./lib/Translation"));
+const getTranslation_1 = __importDefault(require("./getTranslation"));
+const ServerTranslation = ({ term, components, query, removeUnusedQueries }) => {
+    const { t } = (0, getTranslation_1.default)();
+    const text = t(term, { query, removeUnusedQueries });
+    return (react_1.default.createElement(Translation_1.default, { term: term, text: text, components: components }));
+};
+exports.default = ServerTranslation;

package/dist/configuration/CacheHandler.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheHandler = void 0;
+class CacheHandler {
+    cache;
+    constructor() {
+        this.cache = new Map();
+    }
+    async get(key) {
+        return this.cache.get(key);
+    }
+    async set(key, data) {
+        this.cache.set(key, data);
+    }
+    async has(key) {
+        return this.cache.has(key);
+    }
+}
+exports.CacheHandler = CacheHandler;

package/dist/configuration/DataLoader.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isPromise_1 = require("../helpers/isPromise");
+const CacheHandler_1 = require("./CacheHandler");
+class DataLoader {
+    cache = {};
+    loadTranslates;
+    revalidate;
+    cacheHandler = new CacheHandler_1.CacheHandler();
+    checkIsActual;
+    retryAttempts;
+    languages;
+    constructor(opts) {
+        this.loadTranslates = opts.load;
+        this.revalidate = opts.revalidate;
+        this.checkIsActual = opts.checkIsActual;
+        this.retryAttempts = opts.retryAttempts || 3;
+        this.languages = opts.languages || [];
+    }
+    async prolongCache(lang) {
+        const prevMeta = this.cache[lang];
+        if (prevMeta && !(0, isPromise_1.isPromise)(prevMeta)) {
+            prevMeta.lastUpdated = Date.now();
+        }
+    }
+    async actualizeData(lang, lastLoadMeta) {
+        const isOutdatedCache = !lastLoadMeta || (this.revalidate !== undefined && this.revalidate !== false && (lastLoadMeta.lastUpdated + (1000 * this.revalidate) < Date.now()));
+        if (isOutdatedCache) {
+            this.cache[lang] = new Promise(async (resolve) => {
+                if (this.checkIsActual) {
+                    const isActual = await this.callWithRetries(() => this.checkIsActual(lang, lastLoadMeta));
+                    if (isActual) {
+                        this.prolongCache(lang);
+                        resolve(undefined);
+                    }
+                }
+                const fullData = await this.callWithRetries(() => this.loadTranslates(lang));
+                if (!fullData?.data) {
+                    throw new Error(`No data key in load response for lang: ${lang}`);
+                }
+                this.cacheHandler.set(lang, fullData.data);
+                this.cache[lang] = {
+                    ...fullData.meta,
+                    lastUpdated: Date.now(),
+                    isRevalidated: false,
+                };
+                resolve(fullData.data);
+            });
+            const data = await this.cache[lang];
+            return data;
+        }
+    }
+    async load(lang) {
+        if (!this.languages.includes(lang)) {
+            console.error(`Unknown language: ${lang}`);
+            return {};
+        }
+        const cache = this.cache;
+        try {
+            const lastLoadResult = cache[lang];
+            /** We are still loading */
+            if ((0, isPromise_1.isPromise)(lastLoadResult)) {
+                const data = await cache[lang];
+                return data;
+            }
+            /** Cache doesn't exist or it's outdated */
+            const actualData = await this.actualizeData(lang, lastLoadResult);
+            if (actualData)
+                return actualData;
+        }
+        catch (e) {
+            console.error(`Can\'t load actual data for lang ${lang}: `, e);
+        }
+        const isCacheExist = await this.cacheHandler.has(lang);
+        if (isCacheExist) {
+            return this.cacheHandler.get(lang);
+        }
+        throw new Error('Can\'t load data or read from cache');
+    }
+    async revalidateTag(lang) {
+        const prevMeta = this.cache[lang];
+        if (prevMeta && !(0, isPromise_1.isPromise)(prevMeta)) {
+            prevMeta.isRevalidated = true;
+            await this.load(lang);
+        }
+    }
+    async callWithRetries(cb) {
+        let attempts = 0;
+        const call = async () => {
+            try {
+                attempts += 1;
+                return await cb();
+            }
+            catch {
+                if (attempts === this.retryAttempts) {
+                    throw new Error('Can\'t load data');
+                }
+                console.warn('Can\'t load data, trying again...');
+                call();
+            }
+        };
+        return call();
+    }
+}
+exports.default = DataLoader;

package/dist/configuration/createCacheServer.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const getConfig_1 = __importDefault(require("./getConfig"));
+const http_1 = __importDefault(require("http"));
+const DataLoader_1 = __importDefault(require("./DataLoader"));
+async function createCacheServer(port) {
+    const serverSecret = crypto_1.default.randomBytes(32).toString('hex');
+    const config = await (0, getConfig_1.default)();
+    const dataLoader = new DataLoader_1.default(config);
+    const server = http_1.default.createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url || '/', 'http://n');
+            const secret = url.searchParams.get('secret');
+            const lang = url.searchParams.get('lang');
+            const type = url.searchParams.get('type');
+            if (type === 'dev' && process.env.NODE_ENV === 'development') {
+                return res.end(JSON.stringify({ secret: serverSecret }));
+            }
+            if (secret !== serverSecret || !lang) {
+                return res.end();
+            }
+            const data = await dataLoader.load(lang);
+            res.end(JSON.stringify(data));
+        }
+        catch (e) {
+            console.log('error on data loading', e);
+        }
+    });
+    await new Promise((resolve) => {
+        server.listen(+port, 'localhost', () => {
+            resolve(1);
+        });
+    });
+    process.on('SIGINT', () => {
+        server.close();
+    });
+    process.on('SIGQUIT', () => {
+        server.close();
+    });
+    process.on('SIGTERM', () => {
+        server.close();
+    });
+    return {
+        secret: serverSecret,
+    };
+}
+exports.default = createCacheServer;

package/dist/configuration/getConfig.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const CONFIG_PATH = path_1.default.join(process.cwd(), 'nimpl-i18n.js');
+// Crutch bypass of conversion by the assembler to require
+const dynamicImport = new Function('p', 'return import(p)');
+const getConfig = async () => {
+    try {
+        if (fs_1.default.existsSync(CONFIG_PATH)) {
+            const config = await dynamicImport((0, url_1.pathToFileURL)(CONFIG_PATH).href);
+            const { load, languages } = config.default;
+            if (!load) {
+                throw new Error(`Can't find loaderProvider - https://github.com/vordgi/nimpl-i18n#configuration`);
+            }
+            if (!languages) {
+                throw new Error(`Can't find loaderProvider - https://github.com/vordgi/nimpl-i18n#configuration`);
+            }
+            return config.default;
+        }
+    }
+    catch {
+        //
+    }
+    throw new Error('Can\'t load config - https://github.com/vordgi/nimpl-i18n#configuration');
+};
+exports.default = getConfig;

package/dist/configuration/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/createTranslation.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const object_path_1 = __importDefault(require("object-path"));
+const formatServerTranslate_1 = __importDefault(require("./lib/formatServerTranslate"));
+const getDictionary_1 = __importDefault(require("./lib/getDictionary"));
+const createTranslation = async (lang, namespace) => {
+    const dictionary = await (0, getDictionary_1.default)(lang);
+    const namespaceDictionary = namespace ? object_path_1.default.get(dictionary, namespace) : dictionary;
+    const t = (term, opts) => {
+        let termDictionary = namespaceDictionary;
+        let termNamespace = namespace;
+        let termKey = term;
+        if (term.includes(':')) {
+            [termNamespace, termKey] = term.split(':');
+            termDictionary = object_path_1.default.get(dictionary, termNamespace);
+        }
+        const translation = object_path_1.default.get(namespaceDictionary, termKey);
+        const fullTerm = `${termNamespace ? `${termNamespace}.` : ''}${termKey}`;
+        if (typeof translation !== 'string' || !translation)
+            return fullTerm;
+        return (0, formatServerTranslate_1.default)({ term: fullTerm, text: translation, parseEntities: true, ...opts });
+    };
+    return { t, lang };
+};
+exports.default = createTranslation;

package/dist/getTranslation.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const object_path_1 = __importDefault(require("object-path"));
+const get_server_context_1 = __importDefault(require("next-impl-getters/get-server-context"));
+const I18nContext_1 = require("./lib/I18nContext");
+const formatServerTranslate_1 = __importDefault(require("./lib/formatServerTranslate"));
+const getTranslation = (namespace) => {
+    const context = (0, get_server_context_1.default)(I18nContext_1.I18nContext);
+    if (!context) {
+        throw new Error('Please, Init I18nProvider - https://nimpl.tech/i18n/usage#i18nprovider');
+    }
+    const { dictionary, lang } = context;
+    const namespaceDictionary = namespace ? object_path_1.default.get(dictionary, namespace) : dictionary;
+    const t = (term, opts) => {
+        let termDictionary = namespaceDictionary;
+        let termNamespace = namespace;
+        let termKey = term;
+        if (term.includes(':')) {
+            [termNamespace, termKey] = term.split(':');
+            termDictionary = object_path_1.default.get(dictionary, termNamespace);
+        }
+        const translation = object_path_1.default.get(namespaceDictionary, termKey);
+        const fullTerm = `${termNamespace ? `${termNamespace}.` : ''}${termKey}`;
+        if (typeof translation !== 'string' || !translation)
+            return fullTerm;
+        return (0, formatServerTranslate_1.default)({ term: fullTerm, text: translation, parseEntities: true, ...opts });
+    };
+    return { t, lang };
+};
+exports.default = getTranslation;

package/dist/helpers/isPromise.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = void 0;
+const isPromise = (el) => {
+    if (el && typeof el === 'object' && 'then' in el) {
+        return true;
+    }
+    return false;
+};
+exports.isPromise = isPromise;

package/dist/lib/ClientI18nContext.js

@@ -0,0 +1,6 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientI18nContext = void 0;
+const react_1 = require("react");
+exports.ClientI18nContext = (0, react_1.createContext)(null);

package/dist/lib/ClientI18nProvider.js

@@ -0,0 +1,36 @@
+"use strict";
+'use client';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const ClientI18nContext_1 = require("./ClientI18nContext");
+const ClientI18nProvider = ({ translates, children, lang, cleanThread }) => {
+    const prevTranslates = (0, react_1.useContext)(ClientI18nContext_1.ClientI18nContext);
+    if (cleanThread) {
+        Object.assign(translates, prevTranslates?.translates);
+    }
+    return (react_1.default.createElement(ClientI18nContext_1.ClientI18nContext.Provider, { value: { lang, translates } }, children));
+};
+exports.default = ClientI18nProvider;

package/dist/lib/I18nContext.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nContext = void 0;
+const create_server_context_1 = __importDefault(require("next-impl-getters/create-server-context"));
+exports.I18nContext = (0, create_server_context_1.default)(null);

package/dist/lib/Translation.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console, react/no-array-index-key */
+const react_1 = __importDefault(require("react"));
+const Translation = ({ term, text, components }) => {
+    const parts = text.split(/<\/?[a-zA-Z0-9]+>|<[a-zA-Z0-9]+ ?\/>/gm).map((el, i) => react_1.default.createElement(react_1.default.Fragment, { key: `p-${i}` }, el));
+    if (components) {
+        const tags = text.match(/<\/?[a-zA-Z0-9]+>|<[a-zA-Z0-9]+ ?\/>/gm);
+        const openedTags = [];
+        tags?.forEach((tag, tagIndex) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const tagName = tag.match(/[a-zA-Z0-9]+/)[0];
+            if (tag.match(/<[a-zA-Z0-9]+ ?\/>/)) {
+                const component = components[tagName];
+                if (component) {
+                    parts.splice(tagIndex + 1, 1, react_1.default.cloneElement(component, { key: `c-${tagIndex}` }, component.props.children));
+                }
+                else {
+                    console.warn(`Unknown component for term "${term}" - ${tagName}`);
+                }
+            }
+            else if (tag.match(/<\/[a-zA-Z0-9]+>/)) {
+                const openedTagIndex = openedTags.findIndex((i) => i.tag === tagName);
+                if (openedTagIndex !== -1) {
+                    const lastOpenedIndex = openedTags.length - 1 - openedTagIndex;
+                    const openedTagsLength = openedTags.length;
+                    for (let i = openedTagsLength; i > lastOpenedIndex; i--) {
+                        const targetIndex = i - 1;
+                        const targetTag = openedTags[targetIndex];
+                        const component = components[targetTag.tag];
+                        if (component) {
+                            const children = parts.slice(targetTag.position + 1, tagIndex + 1)
+                                .filter((c) => Boolean(c.props.children));
+                            parts.splice(targetTag.position + 1, // parts на 1 больше
+                            tagIndex - targetTag.position, react_1.default.cloneElement(component, { key: `${tagIndex}-${targetIndex}` }, children.length ? children : component.props.children));
+                        }
+                        else {
+                            console.warn(`Unknown component for term "${term}" - ${targetTag}`);
+                        }
+                        openedTags.splice(targetIndex, 1);
+                    }
+                }
+            }
+            else {
+                openedTags.push({ tag: tagName, position: tagIndex });
+            }
+        });
+    }
+    return (parts);
+};
+exports.default = Translation;

package/dist/lib/formatServerTranslate.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_entities_1 = require("html-entities");
+const injectQuery_1 = __importDefault(require("./injectQuery"));
+const formatServerTranslate = ({ term, text, removeUnusedQueries, query, parseEntities }) => {
+    let newTranslate = text;
+    if (query) {
+        newTranslate = (0, injectQuery_1.default)({ term, text: newTranslate, query, removeUnusedQueries });
+    }
+    if (parseEntities === undefined || parseEntities === true) {
+        newTranslate = (0, html_entities_1.decode)(newTranslate, { scope: 'strict' });
+    }
+    return newTranslate;
+};
+exports.default = formatServerTranslate;

package/dist/lib/getDictionary.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getDictionary = async (lang) => {
+    const origFetch = globalThis._nextOriginalFetch || fetch;
+    const dataResp = await origFetch(`http://localhost:${process.env.I18N_CACHE_PORT}/?secret=${process.env.I18N_CACHE_SECRET}&lang=${lang}`, { cache: 'no-cache' });
+    const data = await dataResp.json();
+    return data;
+};
+exports.default = getDictionary;

package/dist/lib/injectQuery.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const injectQuery = ({ text, query, removeUnusedQueries }) => {
+    const newText = text.replace(/{{([a-zA-Z0-9_-]+)}}/gm, (matched, g1) => {
+        if (query[g1]) {
+            return query[g1].toString();
+        }
+        if (removeUnusedQueries) {
+            return '';
+        }
+        else {
+            return matched;
+        }
+    });
+    return newText;
+};
+exports.default = injectQuery;

package/dist/lib/parseEntities.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_entities_1 = require("html-entities");
+const parseEntities = (translate) => {
+    return (0, html_entities_1.decode)(translate, { scope: 'strict' });
+};
+exports.default = parseEntities;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/useTranslation.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const ClientI18nContext_1 = require("./lib/ClientI18nContext");
+const injectQuery_1 = __importDefault(require("./lib/injectQuery"));
+const useTranslation = (namespace) => {
+    const context = (0, react_1.useContext)(ClientI18nContext_1.ClientI18nContext);
+    if (!context) {
+        throw new Error('Please, Init I18nTransmitter for client components - https://nimpl.tech/i18n/usage#client-components');
+    }
+    const { lang, translates } = context;
+    const t = (term, opts) => {
+        let termKey;
+        if (term.includes(':')) {
+            termKey = term.replace(':', '.');
+        }
+        else {
+            termKey = `${namespace ? `${namespace}.` : ''}${term}`;
+        }
+        const translation = translates[termKey];
+        if (!translation)
+            return termKey;
+        if (opts?.query) {
+            return (0, injectQuery_1.default)({ term, text: translation, query: opts.query, removeUnusedQueries: opts.removeUnusedQueries });
+        }
+        return translation;
+    };
+    return { t, lang };
+};
+exports.default = useTranslation;

package/dist/withI18n.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createCacheServer_1 = __importDefault(require("./configuration/createCacheServer"));
+const PORT = '24';
+let cacheSecret = process.env.I18N_CACHE_SECRET;
+const withI18n = async (phase) => {
+    if (!cacheSecret && process.env.NODE_ENV === 'development') {
+        try {
+            const devResp = await fetch(`http://localhost:${PORT}/?type=dev`);
+            const data = await devResp.json();
+            if (data) {
+                cacheSecret = data.secret;
+            }
+        }
+        catch {
+            //
+        }
+    }
+    if ((phase === 'phase-development-server' || phase === 'phase-production-server') && !cacheSecret) {
+        const { secret } = await (0, createCacheServer_1.default)(PORT);
+        cacheSecret = secret;
+    }
+    process.env.I18N_CACHE_PORT = PORT;
+    if (cacheSecret)
+        process.env.I18N_CACHE_SECRET = cacheSecret;
+    return (nextConfig) => nextConfig;
+};
+exports.default = withI18n;

package/env.d.ts

@@ -0,0 +1 @@
+/// <reference types="react/experimental" />

package/getTranslation.d.ts

@@ -0,0 +1,7 @@
+import { type I18nOptions } from './types';
+type GetTranslationReturnType = {
+    t: (term: string, opts?: I18nOptions) => string;
+    lang: string;
+};
+declare const getTranslation: (namespace?: string) => GetTranslationReturnType;
+export default getTranslation;

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@nimpl/i18n",
+  "version": "1.1.0",
+  "description": "i18n library for working with translations in server and client components",
+  "exports": {
+    "./ClientTranslation": {
+      "default": "./dist/ClientTranslation.js"
+    },
+    "./createTranslation": {
+      "default": "./dist/createTranslation.js"
+    },
+    "./getTranslation": {
+      "default": "./dist/getTranslation.js"
+    },
+    "./I18nProvider": {
+      "default": "./dist/I18nProvider.js"
+    },
+    "./I18nTransmitter": {
+      "default": "./dist/I18nTransmitter.js"
+    },
+    "./ServerTranslation": {
+      "default": "./dist/ServerTranslation.js"
+    },
+    "./types": {
+      "default": "./dist/types.js"
+    },
+    "./useTranslation": {
+      "default": "./dist/useTranslation.js"
+    },
+    "./withI18n": {
+      "default": "./dist/withI18n.js"
+    }
+  },
+  "files": [
+    "dist",
+    "*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "next",
+    "next.js",
+    "server components",
+    "react.js",
+    "i18n",
+    "internationalization",
+    "localization",
+    "l10n",
+    "intl"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/vordgi/nimpl-i18n.git"
+  },
+  "author": {
+    "name": "Savelyev Alexander",
+    "email": "vordgi1@gmail.com",
+    "url": "https://github.com/vordgi/"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "16.11.12",
+    "@types/object-path": "0.11.4",
+    "@types/react": "18.2.43",
+    "react": "18.2.0",
+    "typescript": "5.3.2"
+  },
+  "peerDependencies": {
+    "react": ">= 18.2.0"
+  },
+  "dependencies": {
+    "html-entities": "2.4.0",
+    "next-impl-getters": "0.3.1",
+    "object-path": "0.11.8"
+  }
+}

package/types.d.ts

@@ -0,0 +1,22 @@
+export type Translates = {
+    [key: string]: Translates | string;
+};
+export type GetLangOpts = {
+    pathname: string | null;
+    params: {
+        [key: string]: string | string[];
+    };
+};
+export type Query = {
+    [key: string]: string | number;
+};
+export type I18nOptions = {
+    query?: Query;
+    removeUnusedQueries?: boolean;
+};
+export type I18nContextType = {
+    lang: string;
+    translates: {
+        [key: string]: string;
+    };
+} | null;

package/useTranslation.d.ts

@@ -0,0 +1,7 @@
+import { type I18nOptions } from './types';
+type GetTranslationReturnType = {
+    t: (term: string, opts?: I18nOptions) => string;
+    lang: string;
+};
+declare const useTranslation: (namespace?: string) => GetTranslationReturnType;
+export default useTranslation;

package/withI18n.d.ts

@@ -0,0 +1,2 @@
+declare const withI18n: (phase: string) => Promise<(nextConfig: any) => any>;
+export default withI18n;