i18ntk 4.3.0 → 4.3.1

package/utils/english-placeholder-checker.js

@@ -0,0 +1,162 @@
+const path = require('path');
+const SecurityUtils = require('./security');
+
+const LANGUAGE_PREFIX_PATTERN = /^\s*\[[A-Za-z]{2,3}(?:[-_][A-Za-z0-9]{2,8})?\]\s+\S/;
+
+function isLanguagePrefixPlaceholder(value) {
+  return typeof value === 'string' && LANGUAGE_PREFIX_PATTERN.test(value);
+}
+
+function collectStringLeaves(value, prefix = '') {
+  const leaves = [];
+
+  if (typeof value === 'string') {
+    leaves.push({ key: prefix || '<root>', value });
+    return leaves;
+  }
+
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      const nextPrefix = `${prefix}[${index}]`;
+      leaves.push(...collectStringLeaves(item, nextPrefix));
+    });
+    return leaves;
+  }
+
+  if (value && typeof value === 'object') {
+    for (const [key, child] of Object.entries(value)) {
+      const nextPrefix = prefix ? `${prefix}.${key}` : key;
+      leaves.push(...collectStringLeaves(child, nextPrefix));
+    }
+  }
+
+  return leaves;
+}
+
+function collectJsonFiles(dir, rootDir = dir) {
+  const baseDir = path.resolve(rootDir);
+  const validatedDir = SecurityUtils.validatePath(path.resolve(dir), baseDir);
+  if (!validatedDir || !SecurityUtils.safeExistsSync(validatedDir, baseDir)) return [];
+
+  const stat = SecurityUtils.safeStatSync(validatedDir, baseDir);
+  if (!stat.isDirectory()) return [];
+
+  const results = [];
+  for (const entry of SecurityUtils.safeReaddirSync(validatedDir, baseDir, { withFileTypes: true })) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+    const fullPath = path.join(validatedDir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectJsonFiles(fullPath, baseDir));
+    } else if (entry.isFile() && entry.name.endsWith('.json')) {
+      results.push({
+        fullPath,
+        displayPath: path.relative(baseDir, fullPath) || entry.name
+      });
+    }
+  }
+
+  return results;
+}
+
+function getEnglishLocaleFiles(sourceDir, sourceLanguage = 'en') {
+  const requestedRoot = path.resolve(sourceDir || './locales');
+  const localeRoot = SecurityUtils.validatePath(requestedRoot, process.cwd());
+  if (!localeRoot) return [];
+
+  const files = [];
+  const seen = new Set();
+
+  const addFile = (file) => {
+    const resolved = path.resolve(file.fullPath);
+    if (seen.has(resolved)) return;
+    seen.add(resolved);
+    files.push(file);
+  };
+
+  const languageDir = path.join(localeRoot, sourceLanguage);
+  for (const file of collectJsonFiles(languageDir, languageDir)) {
+    addFile(file);
+  }
+
+  const monolithFile = path.join(localeRoot, `${sourceLanguage}.json`);
+  const monolithStat = SecurityUtils.safeStatSync(monolithFile, localeRoot);
+  if (monolithStat && monolithStat.isFile()) {
+    addFile({
+      fullPath: monolithFile,
+      displayPath: path.basename(monolithFile)
+    });
+  }
+
+  if (files.length === 0 && path.basename(localeRoot).toLowerCase() === sourceLanguage.toLowerCase()) {
+    for (const file of collectJsonFiles(localeRoot, localeRoot)) {
+      addFile(file);
+    }
+  }
+
+  return files.sort((a, b) => a.displayPath.localeCompare(b.displayPath));
+}
+
+function scanEnglishPlaceholders(options = {}) {
+  const sourceDir = options.sourceDir || './locales';
+  const sourceLanguage = options.sourceLanguage || 'en';
+  const localeRoot = SecurityUtils.validatePath(path.resolve(sourceDir), process.cwd()) || process.cwd();
+  const files = getEnglishLocaleFiles(sourceDir, sourceLanguage);
+  const placeholders = [];
+  const errors = [];
+  let keyCount = 0;
+
+  for (const file of files) {
+    try {
+      const content = SecurityUtils.safeReadFileSync(file.fullPath, localeRoot, 'utf8');
+      if (!content) {
+        throw new Error('Unable to read locale file');
+      }
+
+      const parseFailed = { __i18ntkParseFailed: true };
+      const parsed = SecurityUtils.safeParseJSON(content, parseFailed);
+      if (parsed === parseFailed) {
+        throw new Error('Invalid JSON content');
+      }
+
+      const leaves = collectStringLeaves(parsed);
+      keyCount += leaves.length;
+
+      for (const leaf of leaves) {
+        if (isLanguagePrefixPlaceholder(leaf.value)) {
+          placeholders.push({
+            file: file.displayPath,
+            path: file.fullPath,
+            key: leaf.key,
+            value: leaf.value
+          });
+        }
+      }
+    } catch (error) {
+      errors.push({
+        file: file.displayPath,
+        path: file.fullPath,
+        error: error.message
+      });
+    }
+  }
+
+  return {
+    success: placeholders.length === 0 && errors.length === 0,
+    sourceDir: path.resolve(sourceDir),
+    sourceLanguage,
+    fileCount: files.length,
+    keyCount,
+    placeholderCount: placeholders.length,
+    placeholders,
+    errors
+  };
+}
+
+module.exports = {
+  LANGUAGE_PREFIX_PATTERN,
+  collectStringLeaves,
+  getEnglishLocaleFiles,
+  isLanguagePrefixPlaceholder,
+  scanEnglishPlaceholders
+};

package/utils/mini-commander.js

@@ -0,0 +1,179 @@
+/**
+ * Minimal zero-dependency subset of commander used by i18ntk language CLIs.
+ */
+
+function toCamelCase(input) {
+  return String(input || '').replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+function parseOptionDefinition(flags, defaultValue) {
+  const longMatch = flags.match(/--([a-zA-Z0-9-]+)/);
+  const shortMatch = flags.match(/(^|\s)-([a-zA-Z])(\s|,|$)/);
+  const hasValue = /<[^>]+>/.test(flags);
+  const longName = longMatch ? longMatch[1] : null;
+  const shortName = shortMatch ? shortMatch[2] : null;
+  const name = toCamelCase(longName || shortName || '');
+
+  return {
+    flags,
+    hasValue,
+    defaultValue,
+    longFlag: longName ? `--${longName}` : null,
+    shortFlag: shortName ? `-${shortName}` : null,
+    name
+  };
+}
+
+function parseOptions(args, optionDefs) {
+  const options = {};
+
+  for (const def of optionDefs) {
+    if (def.defaultValue !== undefined) {
+      options[def.name] = def.defaultValue;
+    } else if (!def.hasValue) {
+      options[def.name] = false;
+    }
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg || !arg.startsWith('-')) {
+      continue;
+    }
+
+    let matchedDef = null;
+    let inlineValue;
+
+    if (arg.startsWith('--')) {
+      const [flag, value] = arg.split('=', 2);
+      matchedDef = optionDefs.find(def => def.longFlag === flag);
+      inlineValue = value;
+    } else {
+      matchedDef = optionDefs.find(def => def.shortFlag === arg);
+    }
+
+    if (!matchedDef) {
+      continue;
+    }
+
+    if (!matchedDef.hasValue) {
+      options[matchedDef.name] = true;
+      continue;
+    }
+
+    let value = inlineValue;
+    if (value === undefined) {
+      const next = args[i + 1];
+      if (next !== undefined && !String(next).startsWith('-')) {
+        value = next;
+        i++;
+      }
+    }
+
+    options[matchedDef.name] = value !== undefined ? value : '';
+  }
+
+  return options;
+}
+
+class MiniCommand {
+  constructor(name) {
+    this._name = name;
+    this._description = '';
+    this._options = [];
+    this._action = null;
+  }
+
+  description(text) {
+    this._description = text;
+    return this;
+  }
+
+  option(flags, _description, defaultValue) {
+    this._options.push(parseOptionDefinition(flags, defaultValue));
+    return this;
+  }
+
+  action(handler) {
+    this._action = handler;
+    return this;
+  }
+
+  execute(args) {
+    const parsed = parseOptions(args, this._options);
+    if (typeof this._action === 'function') {
+      const result = this._action(parsed);
+      if (result && typeof result.then === 'function') {
+        result.catch(error => {
+          console.error(error && error.message ? error.message : String(error));
+          process.exit(1);
+        });
+      }
+    }
+  }
+}
+
+class MiniProgram {
+  constructor() {
+    this._name = '';
+    this._description = '';
+    this._version = '';
+    this._options = [];
+    this._commands = [];
+    this._opts = {};
+  }
+
+  name(value) {
+    this._name = value;
+    return this;
+  }
+
+  description(value) {
+    this._description = value;
+    return this;
+  }
+
+  version(value) {
+    this._version = value;
+    return this;
+  }
+
+  option(flags, _description, defaultValue) {
+    this._options.push(parseOptionDefinition(flags, defaultValue));
+    return this;
+  }
+
+  command(name) {
+    const command = new MiniCommand(name);
+    this._commands.push(command);
+    return command;
+  }
+
+  opts() {
+    return { ...this._opts };
+  }
+
+  parse(argv = process.argv) {
+    const args = argv.slice(2);
+
+    if (this._commands.length > 0 && args.length > 0 && !args[0].startsWith('-')) {
+      const command = this._commands.find(item => item._name === args[0]);
+      if (command) {
+        command.execute(args.slice(1));
+        return this;
+      }
+    }
+
+    this._opts = parseOptions(args, this._options);
+    return this;
+  }
+}
+
+function createProgram() {
+  return new MiniProgram();
+}
+
+module.exports = {
+  createProgram,
+  program: createProgram()
+};