i18next-cli 1.34.0 → 1.34.1

package/dist/esm/init.js

@@ -1 +1,172 @@
-import t from"inquirer";import{writeFile as e,readFile as n}from"node:fs/promises";import{resolve as o}from"node:path";import{detectConfig as i}from"./heuristic-config.js";async function r(){console.log("Welcome to the i18next-cli setup wizard!"),console.log("Scanning your project for a recommended configuration...");const r=await i();r?console.log("✅ Found a potential project structure. Using it for suggestions."):console.log("Could not detect a project structure. Using standard defaults."),"string"==typeof r?.extract?.input&&(r.extract.input=[r?.extract?.input]),r&&"function"==typeof r.extract?.output&&delete r.extract.output;const a=await t.prompt([{type:"select",name:"fileType",message:"What kind of configuration file do you want?",choices:["TypeScript (i18next.config.ts)","JavaScript (i18next.config.js)"]},{type:"input",name:"locales",message:"What locales does your project support? (comma-separated)",default:r?.locales?.join(",")||"en,de,fr",filter:t=>t.split(",").map(t=>t.trim())},{type:"input",name:"input",message:"What is the glob pattern for your source files?",default:r?.extract?.input?(r.extract.input||[])[0]:"src/**/*.{js,jsx,ts,tsx}"},{type:"input",name:"output",message:"What is the path for your output resource files?",default:"string"==typeof r?.extract?.output?r.extract.output:"public/locales/{{language}}/{{namespace}}.json"}]),s=a.fileType.includes("TypeScript"),c=await async function(){try{const t=o(process.cwd(),"package.json"),e=await n(t,"utf-8");return"module"===JSON.parse(e).type}catch{return!0}}(),p=s?"i18next.config.ts":"i18next.config.js",u={locales:a.locales,extract:{input:a.input,output:a.output}};function f(t,e=2,n=0){const o=t=>" ".repeat(t*e),i=o(n),r=o(n+1);if(null===t||"number"==typeof t||"boolean"==typeof t)return JSON.stringify(t);if("string"==typeof t)return JSON.stringify(t);if(Array.isArray(t)){if(0===t.length)return"[]";return`[\n${t.map(t=>`${r}${f(t,e,n+1)}`).join(",\n")}\n${i}]`}if("object"==typeof t){const o=Object.keys(t);if(0===o.length)return"{}";return`{\n${o.map(o=>{const i=/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(o)?o:JSON.stringify(o);return`${r}${i}: ${f(t[o],e,n+1)}`}).join(",\n")}\n${i}}`}return JSON.stringify(t)}let l="";l=s?`import { defineConfig } from 'i18next-cli';\n\nexport default defineConfig(${f(u)});`:c?`import { defineConfig } from 'i18next-cli';\n\n/** @type {import('i18next-cli').I18nextToolkitConfig} */\nexport default defineConfig(${f(u)});`:`const { defineConfig } = require('i18next-cli');\n\n/** @type {import('i18next-cli').I18nextToolkitConfig} */\nmodule.exports = defineConfig(${f(u)});`;const g=o(process.cwd(),p);await e(g,l.trim()),console.log(`✅ Configuration file created at: ${g}`)}export{r as runInit};
+import inquirer from 'inquirer';
+import { writeFile, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { detectConfig } from './heuristic-config.js';
+
+/**
+ * Determines if the current project is configured as an ESM project.
+ * Checks the package.json file for `"type": "module"`.
+ *
+ * @returns Promise resolving to true if ESM, false if CommonJS
+ *
+ * @example
+ * ```typescript
+ * const isESM = await isEsmProject()
+ * if (isESM) {
+ *   // Generate ESM syntax
+ * } else {
+ *   // Generate CommonJS syntax
+ * }
+ * ```
+ */
+async function isEsmProject() {
+    try {
+        const packageJsonPath = resolve(process.cwd(), 'package.json');
+        const content = await readFile(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(content);
+        return packageJson.type === 'module';
+    }
+    catch {
+        return true; // Default to ESM if package.json is not found or readable
+    }
+}
+/**
+ * Interactive setup wizard for creating a new i18next-cli configuration file.
+ *
+ * This function provides a guided setup experience that:
+ * 1. Asks the user for their preferred configuration file type (TypeScript or JavaScript)
+ * 2. Collects basic project settings (locales, input patterns, output paths)
+ * 3. Detects the project module system (ESM vs CommonJS) for JavaScript files
+ * 4. Generates an appropriate configuration file with proper syntax
+ * 5. Provides helpful defaults for common use cases
+ *
+ * The generated configuration includes:
+ * - Locale specification
+ * - Input file patterns for source scanning
+ * - Output path templates with placeholders
+ * - Proper imports and exports for the detected module system
+ * - JSDoc type annotations for JavaScript files
+ *
+ * @example
+ * ```typescript
+ * // Run the interactive setup
+ * await runInit()
+ *
+ * // This will create either:
+ * // - i18next.config.ts (TypeScript)
+ * // - i18next.config.js (JavaScript ESM/CommonJS)
+ * ```
+ */
+async function runInit() {
+    console.log('Welcome to the i18next-cli setup wizard!');
+    console.log('Scanning your project for a recommended configuration...');
+    const detectedConfig = await detectConfig();
+    if (detectedConfig) {
+        console.log('✅ Found a potential project structure. Using it for suggestions.');
+    }
+    else {
+        console.log('Could not detect a project structure. Using standard defaults.');
+    }
+    if (typeof detectedConfig?.extract?.input === 'string')
+        detectedConfig.extract.input = [detectedConfig?.extract?.input];
+    // If heuristic detection returned a function for extract.output, don't use it as a prompt default.
+    // Prompt defaults must be strings; leave undefined so the prompt falls back to a sensible default.
+    if (detectedConfig && typeof detectedConfig.extract?.output === 'function') {
+        delete detectedConfig.extract.output;
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'select',
+            name: 'fileType',
+            message: 'What kind of configuration file do you want?',
+            choices: ['TypeScript (i18next.config.ts)', 'JavaScript (i18next.config.js)'],
+        },
+        {
+            type: 'input',
+            name: 'locales',
+            message: 'What locales does your project support? (comma-separated)',
+            default: detectedConfig?.locales?.join(',') || 'en,de,fr',
+            filter: (input) => input.split(',').map(s => s.trim()),
+        },
+        {
+            type: 'input',
+            name: 'input',
+            message: 'What is the glob pattern for your source files?',
+            default: detectedConfig?.extract?.input ? (detectedConfig.extract.input || [])[0] : 'src/**/*.{js,jsx,ts,tsx}',
+        },
+        {
+            type: 'input',
+            name: 'output',
+            message: 'What is the path for your output resource files?',
+            // ensure the default is a string (detectedConfig.extract.output may be a function)
+            default: typeof detectedConfig?.extract?.output === 'string'
+                ? detectedConfig.extract.output
+                : 'public/locales/{{language}}/{{namespace}}.json',
+        },
+    ]);
+    const isTypeScript = answers.fileType.includes('TypeScript');
+    const isEsm = await isEsmProject();
+    const fileName = isTypeScript ? 'i18next.config.ts' : 'i18next.config.js';
+    const configObject = {
+        locales: answers.locales,
+        extract: {
+            input: answers.input,
+            output: answers.output,
+        },
+    };
+    // Helper to serialize a JS value as a JS literal:
+    function toJs(value, indent = 2, level = 0) {
+        const pad = (n) => ' '.repeat(n * indent);
+        const currentPad = pad(level);
+        const nextPad = pad(level + 1);
+        if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+            return JSON.stringify(value);
+        }
+        if (typeof value === 'string') {
+            return JSON.stringify(value); // keeps double quotes and proper escaping
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return '[]';
+            const items = value.map(v => `${nextPad}${toJs(v, indent, level + 1)}`).join(',\n');
+            return `[\n${items}\n${currentPad}]`;
+        }
+        if (typeof value === 'object') {
+            const keys = Object.keys(value);
+            if (keys.length === 0)
+                return '{}';
+            const entries = keys.map(key => {
+                // Use unquoted key if it's a valid identifier otherwise JSON.stringify(key)
+                const validId = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+                const printedKey = validId ? key : JSON.stringify(key);
+                return `${nextPad}${printedKey}: ${toJs(value[key], indent, level + 1)}`;
+            }).join(',\n');
+            return `{\n${entries}\n${currentPad}}`;
+        }
+        // Fallback
+        return JSON.stringify(value);
+    }
+    let fileContent = '';
+    if (isTypeScript) {
+        fileContent = `import { defineConfig } from 'i18next-cli';
+
+export default defineConfig(${toJs(configObject)});`;
+    }
+    else if (isEsm) {
+        fileContent = `import { defineConfig } from 'i18next-cli';
+
+/** @type {import('i18next-cli').I18nextToolkitConfig} */
+export default defineConfig(${toJs(configObject)});`;
+    }
+    else { // CJS
+        fileContent = `const { defineConfig } = require('i18next-cli');
+
+/** @type {import('i18next-cli').I18nextToolkitConfig} */
+module.exports = defineConfig(${toJs(configObject)});`;
+    }
+    const outputPath = resolve(process.cwd(), fileName);
+    await writeFile(outputPath, fileContent.trim());
+    console.log(`✅ Configuration file created at: ${outputPath}`);
+}
+
+export { runInit };

package/dist/esm/linter.js

@@ -1 +1,425 @@
-import{glob as e}from"glob";import{readFile as t}from"node:fs/promises";import{parse as r}from"@swc/core";import{extname as n}from"node:path";import{EventEmitter as s}from"node:events";import o from"chalk";import a from"ora";const i=["a","abbr","address","article","aside","bdi","bdo","blockquote","button","caption","cite","code","data","dd","del","details","dfn","dialog","div","dt","em","figcaption","footer","h1","h2","h3","h4","h5","h6","header","img","ins","kbd","label","legend","li","main","mark","nav","option","output","p","pre","q","s","samp","section","small","span","strong","sub","summary","sup","td","textarea","th","time","title","var"].map(e=>e.toLowerCase()),c=["abbr","accesskey","alt","aria-description","aria-label","aria-placeholder","aria-roledescription","aria-valuetext","content","label","placeholder","summary","title"].map(e=>e.toLowerCase()),l=["className","key","id","style","href","i18nKey","defaults","type","target"].map(e=>e.toLowerCase()),p=["script","style","code"];class u extends s{config;constructor(e){super({captureRejections:!0}),this.config=e}wrapError(e){const t="Linter failed to run: ";if(e instanceof Error){if(e.message.startsWith(t))return e;const r=new Error(`${t}${e.message}`);return r.stack=e.stack,r}return new Error(`${t}${String(e)}`)}async run(){const{config:s}=this;try{this.emit("progress",{message:"Finding source files to analyze..."});const o=["node_modules/**"],a=Array.isArray(s.extract.ignore)?s.extract.ignore:s.extract.ignore?[s.extract.ignore]:[],i=Array.isArray(s.lint?.ignore)?s.lint.ignore:s.lint?.ignore?[s.lint.ignore]:[],c=await e(s.extract.input,{ignore:[...o,...a,...i]});this.emit("progress",{message:`Analyzing ${c.length} source files...`});let l=0;const p=new Map;for(const e of c){const o=await t(e,"utf-8"),a=n(e).toLowerCase(),i=".ts"===a||".tsx"===a||".mts"===a||".cts"===a,c=".tsx"===a,u=".jsx"===a;let m;try{m=await r(o,{syntax:i?"typescript":"ecmascript",tsx:c,jsx:u,decorators:!0})}catch(t){if(".ts"!==a||c){if(".js"!==a||u){const e=this.wrapError(t);this.emit("error",e);continue}try{m=await r(o,{syntax:"ecmascript",jsx:!0,decorators:!0}),this.emit("progress",{message:`Parsed ${e} using JSX fallback`})}catch(e){const t=this.wrapError(e);this.emit("error",t);continue}}else try{m=await r(o,{syntax:"typescript",tsx:!0,decorators:!0}),this.emit("progress",{message:`Parsed ${e} using TSX fallback`})}catch(e){const t=this.wrapError(e);this.emit("error",t);continue}}const f=d(m,o,s);f.length>0&&(l+=f.length,p.set(e,f))}const u={success:0===l,message:l>0?`Linter found ${l} potential issues.`:"No issues found.",files:Object.fromEntries(p.entries())};return this.emit("done",u),u}catch(e){const t=this.wrapError(e);throw this.emit("error",t),t}}}async function m(e){return new u(e).run()}async function f(e){const t=new u(e),r=a().start();t.on("progress",e=>{r.text=e.message});try{const{success:e,message:n,files:s}=await t.run();if(e)r.succeed(o.green.bold(n));else{r.fail(o.red.bold(n));for(const[e,t]of Object.entries(s))console.log(o.yellow(`\n${e}`)),t.forEach(({text:e,line:t})=>{console.log(`  ${o.gray(`${t}:`)} ${o.red("Error:")} Found hardcoded string: "${e}"`)});process.exit(1)}}catch(e){const n=t.wrapError(e);r.fail(n.message),console.error(n),process.exit(1)}}const g=e=>/^(https|http|\/\/|^\/)/.test(e);function d(e,t,r){const n=[],s=[],o=e=>t.substring(0,e).split("\n").length,a=(r.extract.transComponents||["Trans"]).map(e=>e.toLowerCase()),u=(r?.lint?.ignoredTags||r.extract.ignoredTags||[]).map(e=>e.toLowerCase()),m=new Set([...a,...p.map(e=>e.toLowerCase()),...u]),f=(r?.lint?.ignoredAttributes||r.extract.ignoredAttributes||[]).map(e=>e.toLowerCase()),d=new Set([...l,...f]),y=r?.lint?.acceptedTags?r.lint.acceptedTags:null,h=r?.extract?.acceptedTags?r.extract.acceptedTags:null,b=(y??h??i)?.map(e=>e.toLowerCase())??null,w=r?.lint?.acceptedAttributes?r.lint.acceptedAttributes:null,x=r?.extract?.acceptedAttributes?r.extract.acceptedAttributes:null,S=(w??x??c)?.map(e=>e.toLowerCase())??null,E=b&&b.length>0?new Set(b):null,v=S&&S.length>0?new Set(S):null,C=e=>{if(!e)return null;const t=e.name??e.opening?.name??e.opening?.name;if(!t)return e.opening?.name?C({name:e.opening.name}):null;const r=e=>{if(!e)return null;if("JSXIdentifier"===e.type&&(e.name||e.value))return e.name??e.value;if("Identifier"===e.type&&(e.name||e.value))return e.name??e.value;if("JSXMemberExpression"===e.type){const t=r(e.object),n=r(e.property);return t&&n?`${t}.${n}`:n??t}return e.name??e.value??e.property?.name??e.property?.value??null},n=r(t);return n?String(n):null},J=e=>{if(!e)return null;if("string"==typeof e)return e;if("JSXIdentifier"===e.type||"Identifier"===e.type){const t=e.name??e.value??e.raw??null;return t?String(t):null}if("JSXNamespacedName"===e.type)return J(e.name)??J(e.namespace);if("JSXMemberExpression"===e.type){const t=J(e.object),r=J(e.property);return t&&r?`${t}.${r}`:r??t}if(e.name||e.value||e.property)return e.name??e.value??e.property?.name??e.property?.value??null;try{const t=JSON.stringify(e),r=/"?(?:name|value)"?\s*:\s*"?([a-zA-Z0-9_\-:.$]+)"?/.exec(t);return r?r[1]:null}catch{return null}},X=e=>{for(let t=e.length-1;t>=0;t--){const r=e[t];if(r&&"object"==typeof r&&("JSXElement"===r.type||"JSXOpeningElement"===r.type||"JSXSelfClosingElement"===r.type)){const e=C(r);if(!e)continue;if(m.has(String(e).toLowerCase()))return!0}}if(E){for(let t=e.length-1;t>=0;t--){const r=e[t];if(r&&"object"==typeof r&&("JSXElement"===r.type||"JSXOpeningElement"===r.type||"JSXSelfClosingElement"===r.type)){const e=C(r);if(!e)continue;return!E.has(String(e).toLowerCase())}}return!0}return!1},$=(e,t)=>{if(!e||"object"!=typeof e)return;const r=[...t,e];if("JSXText"===e.type)if(v&&!E);else{if(!X(r)){const t=e.value.trim();t&&t.length>1&&"..."!==t&&!g(t)&&isNaN(Number(t))&&!t.startsWith("{{")&&s.push(e)}}if("StringLiteral"===e.type){const t=r[r.length-2],n=X(r);if("JSXAttribute"===t?.type&&!n){const n=J(t.name),o=n?String(n).toLowerCase():null,a=r.slice(0,-2).reverse().find(e=>e&&"object"==typeof e&&("JSXElement"===e.type||"JSXOpeningElement"===e.type||"JSXSelfClosingElement"===e.type));if(E&&a){const e=C(a);if(!e||!E.has(String(e).toLowerCase()))return}else if(E&&!a)return;if(v?null!=o&&v.has(o):null!=o&&!d.has(o)){const t=e.value.trim();t&&"..."!==t&&!g(t)&&isNaN(Number(t))&&s.push(e)}}}for(const t of Object.keys(e)){if("span"===t)continue;const n=e[t];Array.isArray(n)?n.forEach(e=>$(e,r)):n&&"object"==typeof n&&$(n,r)}};$(e,[]);let L=0;for(const e of s){const r=e.raw??e.value,s=t.indexOf(r,L);s>-1&&(n.push({text:e.value.trim(),line:o(s)}),L=s+r.length)}return n}export{u as Linter,c as recommendedAcceptedAttributes,i as recommendedAcceptedTags,m as runLinter,f as runLinterCli};
+import { glob } from 'glob';
+import { readFile } from 'node:fs/promises';
+import { parse } from '@swc/core';
+import { extname } from 'node:path';
+import { EventEmitter } from 'node:events';
+import chalk from 'chalk';
+import ora from 'ora';
+
+const recommendedAcceptedTags = [
+    'a', 'abbr', 'address', 'article', 'aside', 'bdi', 'bdo', 'blockquote', 'button', 'caption', 'cite', 'code', 'data', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dt', 'em', 'figcaption', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'img', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'mark', 'nav', 'option', 'output', 'p', 'pre', 'q', 's', 'samp', 'section', 'small', 'span', 'strong', 'sub', 'summary', 'sup', 'td', 'textarea', 'th', 'time', 'title', 'var'
+].map(s => s.toLowerCase());
+const recommendedAcceptedAttributes = ['abbr', 'accesskey', 'alt', 'aria-description', 'aria-label', 'aria-placeholder', 'aria-roledescription', 'aria-valuetext', 'content', 'label', 'placeholder', 'summary', 'title'].map(s => s.toLowerCase());
+const defaultIgnoredAttributes = ['className', 'key', 'id', 'style', 'href', 'i18nKey', 'defaults', 'type', 'target'].map(s => s.toLowerCase());
+const defaultIgnoredTags = ['script', 'style', 'code'];
+class Linter extends EventEmitter {
+    config;
+    constructor(config) {
+        super({ captureRejections: true });
+        this.config = config;
+    }
+    wrapError(error) {
+        const prefix = 'Linter failed to run: ';
+        if (error instanceof Error) {
+            if (error.message.startsWith(prefix)) {
+                return error;
+            }
+            const wrappedError = new Error(`${prefix}${error.message}`);
+            wrappedError.stack = error.stack;
+            return wrappedError;
+        }
+        return new Error(`${prefix}${String(error)}`);
+    }
+    async run() {
+        const { config } = this;
+        try {
+            this.emit('progress', { message: 'Finding source files to analyze...' });
+            const defaultIgnore = ['node_modules/**'];
+            const extractIgnore = Array.isArray(config.extract.ignore)
+                ? config.extract.ignore
+                : config.extract.ignore ? [config.extract.ignore] : [];
+            const lintIgnore = Array.isArray(config.lint?.ignore)
+                ? config.lint.ignore
+                : config.lint?.ignore ? [config.lint.ignore] : [];
+            const sourceFiles = await glob(config.extract.input, {
+                ignore: [...defaultIgnore, ...extractIgnore, ...lintIgnore]
+            });
+            this.emit('progress', { message: `Analyzing ${sourceFiles.length} source files...` });
+            let totalIssues = 0;
+            const issuesByFile = new Map();
+            for (const file of sourceFiles) {
+                const code = await readFile(file, 'utf-8');
+                // Determine parser options from file extension so .ts is not parsed as TSX
+                const fileExt = extname(file).toLowerCase();
+                const isTypeScriptFile = fileExt === '.ts' || fileExt === '.tsx' || fileExt === '.mts' || fileExt === '.cts';
+                const isTSX = fileExt === '.tsx';
+                const isJSX = fileExt === '.jsx';
+                let ast;
+                try {
+                    ast = await parse(code, {
+                        syntax: isTypeScriptFile ? 'typescript' : 'ecmascript',
+                        tsx: isTSX,
+                        jsx: isJSX,
+                        decorators: true
+                    });
+                }
+                catch (err) {
+                    // Fallback for .ts files with JSX
+                    if (fileExt === '.ts' && !isTSX) {
+                        try {
+                            ast = await parse(code, {
+                                syntax: 'typescript',
+                                tsx: true,
+                                decorators: true
+                            });
+                            this.emit('progress', { message: `Parsed ${file} using TSX fallback` });
+                        }
+                        catch (err2) {
+                            const wrapped = this.wrapError(err2);
+                            this.emit('error', wrapped);
+                            continue;
+                        }
+                        // Fallback for .js files with JSX
+                    }
+                    else if (fileExt === '.js' && !isJSX) {
+                        try {
+                            ast = await parse(code, {
+                                syntax: 'ecmascript',
+                                jsx: true,
+                                decorators: true
+                            });
+                            this.emit('progress', { message: `Parsed ${file} using JSX fallback` });
+                        }
+                        catch (err2) {
+                            const wrapped = this.wrapError(err2);
+                            this.emit('error', wrapped);
+                            continue;
+                        }
+                    }
+                    else {
+                        const wrapped = this.wrapError(err);
+                        this.emit('error', wrapped);
+                        continue;
+                    }
+                }
+                const hardcodedStrings = findHardcodedStrings(ast, code, config);
+                if (hardcodedStrings.length > 0) {
+                    totalIssues += hardcodedStrings.length;
+                    issuesByFile.set(file, hardcodedStrings);
+                }
+            }
+            const files = Object.fromEntries(issuesByFile.entries());
+            const data = { success: totalIssues === 0, message: totalIssues > 0 ? `Linter found ${totalIssues} potential issues.` : 'No issues found.', files };
+            this.emit('done', data);
+            return data;
+        }
+        catch (error) {
+            const wrappedError = this.wrapError(error);
+            this.emit('error', wrappedError);
+            throw wrappedError;
+        }
+    }
+}
+/**
+ * Runs the i18next linter to detect hardcoded strings and other potential issues.
+ *
+ * This function performs static analysis on source files to identify:
+ * - Hardcoded text strings in JSX elements
+ * - Hardcoded strings in JSX attributes (like alt text, titles, etc.)
+ * - Text that should be extracted for translation
+ *
+ * The linter respects configuration settings:
+ * - Uses the same input patterns as the extractor
+ * - Ignores content inside configured Trans components
+ * - Skips technical content like script/style tags
+ * - Identifies numeric values and interpolation syntax to avoid false positives
+ *
+ * @param config - The toolkit configuration with input patterns and component names
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   extract: {
+ *     input: ['src/**\/*.{ts,tsx}'],
+ *     transComponents: ['Trans', 'Translation']
+ *   }
+ * }
+ *
+ * await runLinter(config)
+ * // Outputs issues found or success message
+ * ```
+ */
+async function runLinter(config) {
+    return new Linter(config).run();
+}
+async function runLinterCli(config) {
+    const linter = new Linter(config);
+    const spinner = ora().start();
+    linter.on('progress', (event) => {
+        spinner.text = event.message;
+    });
+    try {
+        const { success, message, files } = await linter.run();
+        if (!success) {
+            spinner.fail(chalk.red.bold(message));
+            // Print detailed report after spinner fails
+            for (const [file, issues] of Object.entries(files)) {
+                console.log(chalk.yellow(`\n${file}`));
+                issues.forEach(({ text, line }) => {
+                    console.log(`  ${chalk.gray(`${line}:`)} ${chalk.red('Error:')} Found hardcoded string: "${text}"`);
+                });
+            }
+            process.exit(1);
+        }
+        else {
+            spinner.succeed(chalk.green.bold(message));
+        }
+    }
+    catch (error) {
+        const wrappedError = linter.wrapError(error);
+        spinner.fail(wrappedError.message);
+        console.error(wrappedError);
+        process.exit(1);
+    }
+}
+const isUrlOrPath = (text) => /^(https|http|\/\/|^\/)/.test(text);
+/**
+ * Analyzes an AST to find potentially hardcoded strings that should be translated.
+ *
+ * This function traverses the syntax tree looking for:
+ * 1. JSX text nodes with translatable content
+ * 2. String literals in JSX attributes that might need translation
+ *
+ * It applies several filters to reduce false positives:
+ * - Ignores content inside Trans components (already handled)
+ * - Skips script and style tag content (technical, not user-facing)
+ * - Filters out numeric values (usually not translatable)
+ * - Ignores interpolation syntax starting with `{{`
+ * - Filters out ellipsis/spread operator notation `...`
+ * - Only reports non-empty, trimmed strings
+ *
+ * @param config - The toolkit configuration with input patterns and component names
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   extract: {
+ *     input: ['src/**\/*.{ts,tsx}'],
+ *     transComponents: ['Trans', 'Translation']
+ *   }
+ * }
+ *
+ * await runLinter(config)
+ * // Outputs issues found or success message
+ * ```
+ */
+function findHardcodedStrings(ast, code, config) {
+    const issues = [];
+    // A list of AST nodes that have been identified as potential issues.
+    const nodesToLint = [];
+    const getLineNumber = (pos) => {
+        return code.substring(0, pos).split('\n').length;
+    };
+    const transComponents = (config.extract.transComponents || ['Trans']).map((s) => s.toLowerCase());
+    const customIgnoredTags = (config?.lint?.ignoredTags || config.extract.ignoredTags || []).map((s) => s.toLowerCase());
+    const allIgnoredTags = new Set([...transComponents, ...defaultIgnoredTags.map(s => s.toLowerCase()), ...customIgnoredTags]);
+    const customIgnoredAttributes = (config?.lint?.ignoredAttributes || config.extract.ignoredAttributes || []).map((s) => s.toLowerCase());
+    const ignoredAttributes = new Set([...defaultIgnoredAttributes, ...customIgnoredAttributes]);
+    const lintAcceptedTags = config?.lint?.acceptedTags ? config.lint.acceptedTags : null;
+    const extractAcceptedTags = config?.extract?.acceptedTags ? config.extract.acceptedTags : null;
+    const acceptedTagsList = (lintAcceptedTags ?? extractAcceptedTags ?? recommendedAcceptedTags)?.map((s) => s.toLowerCase()) ?? null;
+    const lintAcceptedAttrs = config?.lint?.acceptedAttributes ? config.lint.acceptedAttributes : null;
+    const extractAcceptedAttrs = config?.extract?.acceptedAttributes ? config.extract.acceptedAttributes : null;
+    const acceptedAttributesList = (lintAcceptedAttrs ?? extractAcceptedAttrs ?? recommendedAcceptedAttributes)?.map((s) => s.toLowerCase()) ?? null;
+    const acceptedTagsSet = acceptedTagsList && acceptedTagsList.length > 0 ? new Set(acceptedTagsList) : null;
+    const acceptedAttributesSet = acceptedAttributesList && acceptedAttributesList.length > 0 ? new Set(acceptedAttributesList) : null;
+    // Helper: robustly extract a JSX element name from different node shapes
+    const extractJSXName = (node) => {
+        if (!node)
+            return null;
+        // node might be JSXOpeningElement / JSXSelfClosingElement (has .name)
+        const nameNode = node.name ?? node.opening?.name ?? node.opening?.name;
+        if (!nameNode) {
+            // maybe this node is a full JSXElement with opening.name
+            if (node.opening?.name)
+                return extractJSXName({ name: node.opening.name });
+            return null;
+        }
+        const fromIdentifier = (n) => {
+            if (!n)
+                return null;
+            if (n.type === 'JSXIdentifier' && (n.name || n.value))
+                return (n.name ?? n.value);
+            if (n.type === 'Identifier' && (n.name || n.value))
+                return (n.name ?? n.value);
+            if (n.type === 'JSXMemberExpression') {
+                const object = fromIdentifier(n.object);
+                const property = fromIdentifier(n.property);
+                return object && property ? `${object}.${property}` : (property ?? object);
+            }
+            // fallback attempts
+            return n.name ?? n.value ?? n.property?.name ?? n.property?.value ?? null;
+        };
+        const rawName = fromIdentifier(nameNode);
+        return rawName ? String(rawName) : null;
+    };
+    // Helper: extract attribute name from a JSXAttribute.name node
+    const extractAttrName = (nameNode) => {
+        if (!nameNode)
+            return null;
+        // Direct string (unlikely, but be defensive)
+        if (typeof nameNode === 'string')
+            return nameNode;
+        // Common SWC shapes:
+        // JSXIdentifier: { type: 'JSXIdentifier', value: 'alt' } or { name: 'alt' }
+        if (nameNode.type === 'JSXIdentifier' || nameNode.type === 'Identifier') {
+            const n = (nameNode.name ?? nameNode.value ?? nameNode.raw ?? null);
+            return n ? String(n) : null;
+        }
+        // JSXNamespacedName: { type: 'JSXNamespacedName', namespace: {...}, name: {...} }
+        if (nameNode.type === 'JSXNamespacedName') {
+            // prefer the local name (after the colon)
+            return extractAttrName(nameNode.name) ?? extractAttrName(nameNode.namespace);
+        }
+        // Member-like expressions (defensive)
+        if (nameNode.type === 'JSXMemberExpression') {
+            const left = extractAttrName(nameNode.object);
+            const right = extractAttrName(nameNode.property);
+            if (left && right)
+                return `${left}.${right}`;
+            return right ?? left;
+        }
+        // Some AST variants put the identifier under `.name` or `.value`
+        if (nameNode.name || nameNode.value || nameNode.property) {
+            return (nameNode.name ?? nameNode.value ?? nameNode.property?.name ?? nameNode.property?.value ?? null);
+        }
+        // Last-resort: try to stringify and extract an identifier-looking token
+        try {
+            const s = JSON.stringify(nameNode);
+            const m = /"?(?:name|value)"?\s*:\s*"?([a-zA-Z0-9_\-:.$]+)"?/.exec(s);
+            return m ? m[1] : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Helper: return true if any JSX ancestor is in the ignored tags set
+    const isWithinIgnoredElement = (ancestors) => {
+        // First: if ANY ancestor is in the ignored set -> ignore (ignored always wins)
+        for (let i = ancestors.length - 1; i >= 0; i--) {
+            const an = ancestors[i];
+            if (!an || typeof an !== 'object')
+                continue;
+            if (an.type === 'JSXElement' || an.type === 'JSXOpeningElement' || an.type === 'JSXSelfClosingElement') {
+                const name = extractJSXName(an);
+                if (!name)
+                    continue;
+                if (allIgnoredTags.has(String(name).toLowerCase()))
+                    return true;
+            }
+        }
+        // If acceptedTags is set: use nearest enclosing JSX element to decide acceptance
+        if (acceptedTagsSet) {
+            for (let i = ancestors.length - 1; i >= 0; i--) {
+                const an = ancestors[i];
+                if (!an || typeof an !== 'object')
+                    continue;
+                if (an.type === 'JSXElement' || an.type === 'JSXOpeningElement' || an.type === 'JSXSelfClosingElement') {
+                    const name = extractJSXName(an);
+                    if (!name)
+                        continue;
+                    return !acceptedTagsSet.has(String(name).toLowerCase());
+                }
+            }
+            // no enclosing element found -> treat as ignored
+            return true;
+        }
+        // Default: not inside an ignored element
+        return false;
+    };
+    // --- PHASE 1: Collect all potentially problematic nodes ---
+    const walk = (node, ancestors) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const currentAncestors = [...ancestors, node];
+        if (node.type === 'JSXText') {
+            // If acceptedAttributesSet exists but acceptedTagsSet does not, we're in attribute-only mode:
+            // do not collect JSXText nodes when attribute-only mode is active.
+            if (acceptedAttributesSet && !acceptedTagsSet) ;
+            else {
+                const isIgnored = isWithinIgnoredElement(currentAncestors);
+                if (!isIgnored) {
+                    const text = node.value.trim();
+                    if (text && text.length > 1 && text !== '...' && !isUrlOrPath(text) && isNaN(Number(text)) && !text.startsWith('{{')) {
+                        nodesToLint.push(node);
+                    }
+                }
+            }
+        }
+        if (node.type === 'StringLiteral') {
+            const parent = currentAncestors[currentAncestors.length - 2];
+            // Determine whether this attribute is inside any ignored element (handles nested Trans etc.)
+            const insideIgnored = isWithinIgnoredElement(currentAncestors);
+            if (parent?.type === 'JSXAttribute' && !insideIgnored) {
+                const rawAttrName = extractAttrName(parent.name);
+                const attrNameLower = rawAttrName ? String(rawAttrName).toLowerCase() : null;
+                // Check tag-level acceptance if acceptedTagsSet provided: attributes should only be considered
+                // when the nearest enclosing element is accepted.
+                const parentElement = currentAncestors.slice(0, -2).reverse().find(a => a && typeof a === 'object' && (a.type === 'JSXElement' || a.type === 'JSXOpeningElement' || a.type === 'JSXSelfClosingElement'));
+                if (acceptedTagsSet && parentElement) {
+                    const parentName = extractJSXName(parentElement);
+                    if (!parentName || !acceptedTagsSet.has(String(parentName).toLowerCase())) {
+                        // attribute is inside a non-accepted tag -> skip
+                        return;
+                    }
+                }
+                else if (acceptedTagsSet && !parentElement) {
+                    // no enclosing element -> skip
+                    return;
+                }
+                // If acceptedAttributesSet exists, only lint attributes explicitly accepted.
+                const shouldLintAttribute = acceptedAttributesSet
+                    ? (attrNameLower != null && acceptedAttributesSet.has(attrNameLower))
+                    : (attrNameLower != null ? !ignoredAttributes.has(attrNameLower) : false);
+                if (shouldLintAttribute) {
+                    const text = node.value.trim();
+                    // Filter out: empty strings, URLs, numbers, and ellipsis
+                    if (text && text !== '...' && !isUrlOrPath(text) && isNaN(Number(text))) {
+                        nodesToLint.push(node); // Collect the node
+                    }
+                }
+            }
+        }
+        // Recurse into children
+        for (const key of Object.keys(node)) {
+            if (key === 'span')
+                continue;
+            const child = node[key];
+            if (Array.isArray(child)) {
+                child.forEach(item => walk(item, currentAncestors));
+            }
+            else if (child && typeof child === 'object') {
+                walk(child, currentAncestors);
+            }
+        }
+    };
+    walk(ast, []); // Run the walk to collect nodes
+    // --- PHASE 2: Find line numbers using a tracked search on the raw source code ---
+    let lastSearchIndex = 0;
+    for (const node of nodesToLint) {
+        // For StringLiterals, the `raw` property includes the quotes ("..."), which is
+        // much more unique for searching than the plain `value`.
+        const searchText = node.raw ?? node.value;
+        const position = code.indexOf(searchText, lastSearchIndex);
+        if (position > -1) {
+            issues.push({
+                text: node.value.trim(),
+                line: getLineNumber(position),
+            });
+            lastSearchIndex = position + searchText.length;
+        }
+    }
+    return issues;
+}
+
+export { Linter, recommendedAcceptedAttributes, recommendedAcceptedTags, runLinter, runLinterCli };