native-document 1.0.83 → 1.0.84

package/i18n.js

@@ -0,0 +1 @@
+export * from './src/i18n/service/I18nService'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "native-document",
-  "version": "1.0.83",
+  "version": "1.0.84",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -20,5 +20,8 @@
     "eslint": "^9.33.0",
     "magic-string": "^0.30.21",
     "rollup": "^4.53.3"
+  },
+  "dependencies": {
+    "i18next": "^25.8.0"
   }
 }

package/src/i18n/bin/scan.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+import Fs from 'node:fs';
+import Path from 'node:path';
+const configFile = Path.resolve('i18n.scanner.config.json');
+
+const Debug = {
+    $warning: [],
+    warn(category, message, data) {
+        Debug.$warning.push({ message: `[${category}] ${message}`, data });
+    }
+}
+
+function scanFolder(dirPath, callback) {
+    const files = Fs.readdirSync(dirPath);
+
+    files.forEach((file) => {
+        const filePath = Path.join(dirPath, file);
+        const stats = Fs.statSync(filePath);
+
+        if (stats.isDirectory()) {
+            scanFolder(filePath, callback);
+        } else if (stats.isFile()) {
+            // If it's a file, add its path to the list
+            callback(filePath);
+        }
+    });
+}
+
+function scanFile(filePath) {
+    const fileContent = Fs.readFileSync(filePath, 'utf-8');
+    const keys = [];
+    fileContent.replace(/\btr\((.*?)\)/g, function(_, args) {
+        const key = getKey(args, filePath);
+        if(key) {
+            keys.push(key);
+        }
+    });
+    return keys;
+}
+
+function getKey(args, filePath) {
+    const trimmed = args.trim();
+    const firstChar = trimmed[0];
+    if(firstChar !== '"' && firstChar !== "'") {
+        Debug.warn('Key Extract', '', {
+            message: `can't extract key from ("${args}") in file.`,
+            args: args,
+            file: filePath
+        });
+
+        return;
+    }
+    const key = [];
+    let i = 1;
+    while(i < trimmed.length) {
+        const char = trimmed[i];
+        if(char === '\\') {
+            key.push(trimmed[++i]);
+            i++;
+            continue;
+        }
+        if(char === firstChar) {
+            break;
+        }
+        i++;
+        key.push(char);
+    }
+    return key.join('');
+}
+
+function scan() {
+    if(!Fs.existsSync(configFile)) {
+        console.error('Config file not found. Please create i18n.scanner.config.json file in your project root directory.');
+        return;
+    }
+
+    const keys = [];
+    try {
+        const configContent = Fs.readFileSync(configFile, 'utf-8');
+        const config = JSON.parse(configContent);
+        const initialPath = Path.resolve(process.cwd(), config?.scan?.dir || 'src');
+        scanFolder(initialPath, (filePath) => {
+            const fileExtensions = config?.scan?.extensions || ['js'];
+            const shouldScanFile = fileExtensions.some(extension => filePath.endsWith(extension));
+            if(!shouldScanFile) {
+                return;
+            }
+            keys.push(...scanFile(filePath));
+        });
+        if(!config?.locales) {
+            console.log('No locales found in config file.');
+            return;
+        }
+
+        console.log(":: scan locales");
+        scanFolder(config.locales, (filePath) => {
+            if(!filePath.endsWith('.json')) {
+                return;
+            }
+            const locale = Path.basename(filePath, '.json');
+            const localeData = JSON.parse(Fs.readFileSync(filePath, 'utf-8'));
+            const localeKeys = Object.keys(localeData);
+            const absentKeys = keys.filter(key => !localeKeys.includes(key));
+
+            const result = absentKeys.reduce((acc, key) => {
+                acc[key] = key;
+                return acc;
+            }, {});
+
+            console.log("-- " + locale + ` : ${absentKeys.length} keys are absent in locale file.`);
+            if(!config?.save) {
+                console.log('-- display result:');
+                console.log(result);
+                return;
+            }
+
+            const saveFile = config.save+'/'+(locale+'.absent.json');
+            const saveFilePath = Path.resolve(process.cwd(), saveFile);
+            console.log('-- save result to ' + saveFile);
+            const dirName = Path.dirname(saveFilePath);
+            if(!Fs.existsSync(saveFilePath)) {
+                Fs.mkdirSync(dirName, { recursive: true });
+            }
+            Fs.writeFileSync(saveFilePath, JSON.stringify(result, null, 4));
+        });
+    } catch (e) {
+        console.log(e);
+    }
+}
+
+scan();

package/src/i18n/service/I18nService.js

@@ -0,0 +1,46 @@
+import i18next from "i18next";
+import {Observable} from "../../../index";
+import {hasObservableParams, getObservableParams, getParams} from "./functions";
+
+const I18nService = (function () {
+    const defaultLang = import.meta.env.VITE_LOCALE || 'en';
+    const $current = Observable(defaultLang);
+    i18next.on('languageChanged', (lng) => $current.set(lng));
+
+    return {
+        init(resources) {
+            return i18next.init({
+                lng: import.meta.env.VITE_LOCALE,
+                fallbackLng: import.meta.env.VITE_FALLBACK_LANGUE || 'en',
+                debug: import.meta.env.VITE_ENV === 'development',
+                resources
+            });
+        },
+        current: $current,
+        use(lng) {
+            return i18next.changeLanguage(lng);
+        },
+        tr(key, ...args) {
+            return i18next.t(key, ...args) || key;
+        }
+    };
+}());
+
+const tr = (key, params = {}) => {
+    const isContainObservable = hasObservableParams(params);
+    const observable = isContainObservable
+        ? Observable.computed(() => I18nService.tr(key, getParams(params)), getObservableParams(params))
+        : Observable(I18nService.tr(key, params));
+
+    i18next.on('languageChanged', (lng) => {
+        const data = isContainObservable ? getParams(params) : params;
+        observable.set(I18nService.tr(key, data));
+    });
+    return observable;
+};
+
+String.prototype.tr = function(params = {}) {
+    return tr(this, params);
+};
+
+export { I18nService, tr };

package/src/i18n/service/functions.js

@@ -0,0 +1,29 @@
+import {Observable} from "../../../index";
+import Validator from "../../core/utils/validator";
+
+export const getParams = (params) => {
+    if(!params) {
+        return {};
+    }
+
+    const result = {};
+    for (const key in params) {
+        result[key] = Observable.value(params[key]);
+    }
+    return result;
+};
+
+export const hasObservableParams = (params) => {
+    if(!params) {
+        return false;
+    }
+    return Validator.isObject(params)
+        && Object.values(params).some(value => Validator.isObservable(value));
+};
+
+export const getObservableParams = (params) => {
+    if(!params) {
+        return [];
+    }
+    return Object.values(params).filter(value => Validator.isObservable(value));
+};