i18ntk 2.0.3 → 2.1.0

package/scripts/fix-all-i18n.js

@@ -8,8 +8,9 @@
  * - Optional: prune extra keys not present in EN
  */
 
-const fs = require('fs');
-const path = require('path');
+const fs = require('fs');
+const path = require('path');
+const SecurityUtils = require('../utils/security');
 
 const argv = Object.fromEntries(
   process.argv.slice(2).map(a => {
@@ -37,11 +38,11 @@ const KEY_PATTERNS = [
 const EXCLUDE_DIRS = new Set(['node_modules', '.git', path.basename(I18N_DIR)]);
 
 function readUTF8(p) { try { return SecurityUtils.safeReadFileSync(p, path.dirname(p), 'utf8'); } catch { return null; } }
-function writeJSON(p, obj) { fs.mkdirSync(path.dirname(p), { recursive: true }); SecurityUtils.safeWriteFileSync(p, JSON.stringify(obj, null, 2) + '\n', 'utf8'); }
+function writeJSON(p, obj) { fs.mkdirSync(path.dirname(p), { recursive: true }); SecurityUtils.safeWriteFileSync(p, JSON.stringify(obj, null, 2) + '\n', path.dirname(p), 'utf8'); }
 function isDir(p) { try { return fs.statSync(p).isDirectory(); } catch { return false; } }
 function isFile(p) { try { return fs.statSync(p).isFile(); } catch { return false; } }
 
-function listFilesRecursive(dir, exts = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']) {
+function listFilesRecursive(dir, exts = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']) {
   const out = [];
   (function walk(d) {
     for (const name of fs.readdirSync(d)) {
@@ -54,22 +55,42 @@ function listFilesRecursive(dir, exts = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '
       } catch {}
     }
   })(dir);
-  return out;
-}
-
-function extractKeysFromSource(file, patterns = KEY_PATTERNS) {
-  const content = readUTF8(file);
-  if (!content) return [];
-  const keys = [];
-  for (const re of patterns) {
-    re.lastIndex = 0;
-    let m; let guard = 0;
-    while ((m = re.exec(content)) && guard++ < 10000) {
-      if (m[1]) keys.push(m[1]);
-    }
-  }
-  return keys;
-}
+  return out;
+}
+
+function normalizeKeyCandidate(rawKey) {
+  if (rawKey === null || rawKey === undefined) return null;
+  let key = String(rawKey).trim();
+  if (!key) return null;
+
+  key = key.replace(/\$\{[^}]+\}/g, '*');
+
+  if (/[\r\n\t]/.test(key)) return null;
+  if (/\s/.test(key)) return null;
+  if (/(=>|\|\||&&|function\b|return\b|includes\()/i.test(key)) return null;
+  if (!/^[A-Za-z0-9_.:*-]+$/.test(key)) return null;
+  if (key.startsWith('.') || key.endsWith('.') || key.includes('..')) return null;
+  if (key === '*' || key.includes('*')) return null;
+
+  return key;
+}
+
+function extractKeysFromSource(file, patterns = KEY_PATTERNS) {
+  const content = readUTF8(file);
+  if (!content) return [];
+  const keys = [];
+  for (const re of patterns) {
+    re.lastIndex = 0;
+    let m; let guard = 0;
+    while ((m = re.exec(content)) && guard++ < 10000) {
+      if (m[1]) {
+        const normalized = normalizeKeyCandidate(m[1]);
+        if (normalized) keys.push(normalized);
+      }
+    }
+  }
+  return keys;
+}
 
 function flatten(obj, prefix = '') {
   const out = {};

package/scripts/fix-and-purify-i18n.js

@@ -48,12 +48,12 @@ const COUNTRY_CODES = { de: 'DE', es: 'ES', fr: 'FR', ru: 'RU', ja: 'JA', zh: 'Z
 function readUTF8(p) {
   try { return SecurityUtils.safeReadFileSync(p, path.dirname(p), 'utf8'); } catch { return null; }
 }
-function writeJSON(p, obj) {
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  SecurityUtils.safeWriteFileSync(p, JSON.stringify(obj, null, 2) + '\n', 'utf8');
-}
-function isDir(p) { try { return fs.statSync(p).isDirectory(); } catch { return false; } }
-function isFile(p) { try { return fs.statSync(p).isFile(); } catch { return false; } }
+function writeJSON(p, obj) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  SecurityUtils.safeWriteFileSync(p, JSON.stringify(obj, null, 2) + '\n', path.dirname(p), 'utf8');
+}
+function isDir(p) { try { return fs.statSync(p).isDirectory(); } catch { return false; } }
+function isFile(p) { try { return fs.statSync(p).isFile(); } catch { return false; } }
 
 function listFilesRecursive(dir, exts = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']) {
   const out = [];
@@ -67,23 +67,43 @@ function listFilesRecursive(dir, exts = ['.js', '.jsx', '.ts', '.tsx', '.mjs', '
         else if (st.isFile() && exts.includes(path.extname(name))) out.push(full);
       } catch {}
     }
-  })(dir);
-  return out;
-}
-
-function extractKeysFromSource(file, patterns = KEY_PATTERNS) {
-  const content = readUTF8(file);
-  if (!content) return [];
-  const keys = [];
-  for (const re of patterns) {
-    re.lastIndex = 0;
-    let m; let guard = 0;
-    while ((m = re.exec(content)) && guard++ < 10000) {
-      if (m[1]) keys.push(m[1]);
-    }
-  }
-  return keys;
-}
+  })(dir);
+  return out;
+}
+
+function normalizeKeyCandidate(rawKey) {
+  if (rawKey === null || rawKey === undefined) return null;
+  let key = String(rawKey).trim();
+  if (!key) return null;
+
+  key = key.replace(/\$\{[^}]+\}/g, '*');
+
+  if (/[\r\n\t]/.test(key)) return null;
+  if (/\s/.test(key)) return null;
+  if (/(=>|\|\||&&|function\b|return\b|includes\()/i.test(key)) return null;
+  if (!/^[A-Za-z0-9_.:*-]+$/.test(key)) return null;
+  if (key.startsWith('.') || key.endsWith('.') || key.includes('..')) return null;
+  if (key === '*' || key.includes('*')) return null;
+
+  return key;
+}
+
+function extractKeysFromSource(file, patterns = KEY_PATTERNS) {
+  const content = readUTF8(file);
+  if (!content) return [];
+  const keys = [];
+  for (const re of patterns) {
+    re.lastIndex = 0;
+    let m; let guard = 0;
+    while ((m = re.exec(content)) && guard++ < 10000) {
+      if (m[1]) {
+        const normalized = normalizeKeyCandidate(m[1]);
+        if (normalized) keys.push(normalized);
+      }
+    }
+  }
+  return keys;
+}
 
 function flatten(obj, prefix = '') {
   const out = {};

package/scripts/prepublish-dev.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+/**
+ * DEVELOPMENT-ONLY Prepublish Script
+ * This script is for development use only and should NEVER be included in production packages
+ * It provides additional development validation and cleanup functionality
+ */
+
+const fs = require('fs');
+const path = require('path');
+const SecurityUtils = require('../utils/security');
+
+class DevelopmentPrepublishCleaner {
+ constructor() {
+ this.projectRoot = path.join(__dirname, '..');
+ this.directories = [
+ 'scripts/debug/logs',
+ 'scripts/debug/reports',
+ 'settings/backups',
+ 'i18ntk-reports',
+ 'reports',
+ 'tests/temp'
+ ];
+ this.files = [
+ 'settings/.i18n-admin-config.json',
+ 'test-*.json',
+ 'debug-*.log',
+ 'npm-debug.log',
+ 'yarn-error.log',
+ '.env',
+ '.env.test'
+ ];
+ 
+ // Essential files that must exist for development
+ this.essentialFiles = [
+ 'package.json',
+ 'main/manage/index.js',
+ 'main/i18ntk-init.js',
+ 'main/i18ntk-analyze.js',
+ 'main/i18ntk-validate.js',
+ 'utils/security.js'
+ ];
+ }
+
+ log(message) {
+ console.log(`[Prepublish-Dev] ${message}`);
+ }
+
+ async clean() {
+ this.log('Starting development pre-publish validation...');
+ 
+ // Validate essential files exist
+ await this.validateEssentialFiles();
+ 
+ // Clean directories
+ for (const dir of this.directories) {
+ await this.cleanDirectory(path.join(this.projectRoot, dir));
+ }
+ 
+ // Clean files
+ for (const file of this.files) {
+ await this.cleanFile(file);
+ }
+ 
+ // Development-specific validations
+ await this.devValidations();
+ 
+ this.log('Development pre-publish validation completed successfully!');
+ }
+
+ async cleanDirectory(dirPath) {
+ const validatedPath = SecurityUtils.validatePath(dirPath, this.projectRoot);
+ if (!validatedPath || !SecurityUtils.safeExistsSync(validatedPath)) {
+ return;
+ }
+
+ try {
+ const files = SecurityUtils.safeReaddirSync(validatedPath, this.projectRoot);
+ let deletedCount = 0;
+
+ for (const file of files) {
+ const filePath = path.join(validatedPath, file);
+ const validatedFilePath = SecurityUtils.validatePath(filePath, this.projectRoot);
+ if (!validatedFilePath) continue;
+
+ const stat = SecurityUtils.safeStatSync(validatedFilePath, this.projectRoot);
+ if (!stat) continue;
+
+ if (stat.isFile()) {
+ if (SecurityUtils.safeExistsSync(validatedFilePath)) {
+ fs.unlinkSync(validatedFilePath);
+ deletedCount++;
+ }
+ } else if (stat.isDirectory()) {
+ // Recursively clean subdirectories
+ await this.cleanDirectory(validatedFilePath);
+ // Remove empty directories
+ try {
+ fs.rmdirSync(validatedFilePath);
+ } catch (e) {
+ // Directory not empty, skip
+ }
+ }
+ }
+
+ if (deletedCount > 0) {
+ this.log(`Cleaned ${deletedCount} files from ${path.relative(this.projectRoot, validatedPath)}`);
+ }
+ } catch (error) {
+ this.log(`Warning: Could not clean ${dirPath}: ${error.message}`);
+ }
+ }
+
+ async cleanFile(pattern) {
+ const searchPath = path.join(this.projectRoot, pattern);
+ const validatedSearchPath = SecurityUtils.validatePath(searchPath, this.projectRoot);
+ if (!validatedSearchPath) return;
+
+ if (pattern.includes('*')) {
+ // Handle glob patterns
+ const dir = path.dirname(validatedSearchPath);
+ const filenamePattern = path.basename(validatedSearchPath);
+ const validatedDir = SecurityUtils.validatePath(dir, this.projectRoot);
+ if (!validatedDir) return;
+
+ if (SecurityUtils.safeExistsSync(validatedDir)) {
+ const files = SecurityUtils.safeReaddirSync(validatedDir, this.projectRoot);
+ const regex = new RegExp(filenamePattern.replace('*', '.*'));
+
+ for (const file of files) {
+ if (regex.test(file)) {
+ const filePath = path.join(validatedDir, file);
+ const validatedFilePath = SecurityUtils.validatePath(filePath, this.projectRoot);
+ if (validatedFilePath && SecurityUtils.safeExistsSync(validatedFilePath)) {
+ fs.unlinkSync(validatedFilePath);
+ this.log(`Deleted ${path.relative(this.projectRoot, validatedFilePath)}`);
+ }
+ }
+ }
+ }
+ } else {
+ // Handle exact files
+ const validatedFilePath = SecurityUtils.validatePath(searchPath, this.projectRoot);
+ if (validatedFilePath && SecurityUtils.safeExistsSync(validatedFilePath)) {
+ fs.unlinkSync(validatedFilePath);
+ this.log(`Deleted ${path.relative(this.projectRoot, validatedFilePath)}`);
+ }
+ }
+ }
+
+ async validateEssentialFiles() {
+ this.log('Validating essential development files...');
+
+ let missingFiles = [];
+ for (const file of this.essentialFiles) {
+ const filePath = path.join(this.projectRoot, file);
+ const validatedPath = SecurityUtils.validatePath(filePath, this.projectRoot);
+ if (!validatedPath || !SecurityUtils.safeExistsSync(validatedPath)) {
+ missingFiles.push(file);
+ } else {
+ const stat = SecurityUtils.safeStatSync(validatedPath, this.projectRoot);
+ if (!stat || !stat.isFile()) {
+ this.log(`❌ ${file} is not a file`);
+ process.exit(1);
+ }
+ }
+ }
+
+ if (missingFiles.length > 0) {
+ this.log(`❌ Missing essential files: ${missingFiles.join(', ')}`);
+ process.exit(1);
+ }
+
+ this.log('✅ All essential development files present');
+ }
+
+ async devValidations() {
+ this.log('Running development-specific validations...');
+ 
+ // Check for test files
+ const testFiles = [
+ 'tests/security.test.js',
+ 'tests/config-system.test.js',
+ 'tests/comprehensive-test.js'
+ ];
+
+ for (const testFile of testFiles) {
+ const testPath = path.join(this.projectRoot, testFile);
+ const validatedPath = SecurityUtils.validatePath(testPath, this.projectRoot);
+ if (!validatedPath || !SecurityUtils.safeExistsSync(validatedPath)) {
+ this.log(`⚠️ Missing test file: ${testFile}`);
+ }
+ }
+ 
+ // Check for development tools
+ const devTools = [
+ '.vscode/',
+ '.idea/',
+ 'node_modules/'
+ ];
+
+ for (const tool of devTools) {
+ const toolPath = path.join(this.projectRoot, tool);
+ const validatedPath = SecurityUtils.validatePath(toolPath, this.projectRoot);
+ if (validatedPath && SecurityUtils.safeExistsSync(validatedPath)) {
+ this.log(`ℹ️ Development tool found: ${tool}`);
+ }
+ }
+ }
+}
+
+// Run if called directly
+if (require.main === module) {
+ const cleaner = new DevelopmentPrepublishCleaner();
+ cleaner.clean().catch(error => {
+ console.error('Error during development cleanup:', error);
+ process.exit(1);
+ });
+}
+
+module.exports = DevelopmentPrepublishCleaner;