@lingual/i18n-check 0.8.18 → 0.9.0-beta.1

package/README.md

@@ -247,7 +247,7 @@ yarn i18n:check --locales translations/folderExamples -s en-US -i "some.path.to.
 
 ### --parser-component-functions
 
-When using the `--unused` option, there will be situations where the i18next-parser will not be able to find components that wrap a `Trans` component.The component names for i18next-parser to match should be provided via the `--parser-component-functions` option. This option should onlybe used to define additional names for matching, a by default `Trans` will always be matched.
+When using the `--unused` option, there will be situations where the i18next-parser will not be able to find components that wrap a `Trans` component. The component names for i18next-parser to match should be provided via the `--parser-component-functions` option. This option should only be used to define additional names for matching, as by default `Trans` will always be matched.
 
 ```bash
 yarn i18n:check --locales translations/i18NextMessageExamples -s en-US -f i18next

package/dist/index.js

@@ -8,6 +8,7 @@ const findMissingKeys_1 = require("./utils/findMissingKeys");
 const findInvalidTranslations_1 = require("./utils/findInvalidTranslations");
 const findInvalidI18NextTranslations_1 = require("./utils/findInvalidI18NextTranslations");
 const cli_lib_1 = require("@formatjs/cli-lib");
+const i18NextSrcParser_1 = require("./utils/i18NextSrcParser");
 const nextIntlSrcParser_1 = require("./utils/nextIntlSrcParser");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -270,25 +271,6 @@ const isRecord = (data) => {
         data !== undefined);
 };
 const getI18NextKeysInCode = async (filesToParse, componentFunctions = []) => {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    const { transform } = await import('i18next-parser');
-    const i18nextParser = new transform({
-        lexers: {
-            jsx: [
-                {
-                    lexer: 'JsxLexer',
-                    componentFunctions: componentFunctions.concat(['Trans']),
-                },
-            ],
-            tsx: [
-                {
-                    lexer: 'JsxLexer',
-                    componentFunctions: componentFunctions.concat(['Trans']),
-                },
-            ],
-        },
-    });
     // Skip any parsed keys that have the `returnObjects` property set to true
     // As these are used dynamically, they will be skipped to prevent
     // these keys from being marked as unused.
@@ -296,7 +278,9 @@ const getI18NextKeysInCode = async (filesToParse, componentFunctions = []) => {
     const skippableKeys = [];
     filesToParse.forEach((file) => {
         const rawContent = fs_1.default.readFileSync(file, 'utf-8');
-        const entries = i18nextParser.parser.parse(rawContent, file);
+        const entries = (0, i18NextSrcParser_1.getKeys)(file, {
+            componentFunctions: componentFunctions.concat(['Trans']),
+        }, rawContent);
         // Intermediate solution to retrieve all keys from the parser.
         // This will be built out to also include the namespace and check
         // the key against the namespace corresponding file.

package/dist/utils/i18NextSrcParser.d.ts

@@ -0,0 +1,35 @@
+/**
+ *
+ * Based on the original [i18next-parser](https://github.com/i18next/i18next-parser)
+ *
+ */
+type Options = {
+    attr: string;
+    componentFunctions: string[];
+    functions: string[];
+    namespaceFunctions: string[];
+    parseGenerics: boolean;
+    transSupportBasicHtmlNodes: boolean;
+    transIdentityFunctionsToIgnore: string[];
+    typeMap: Record<string, unknown>;
+    translationFunctionsWithArgs: Record<string, {
+        pos: number;
+        storeGlobally: boolean;
+        keyPrefix?: string;
+        ns?: string;
+    }>;
+    keyPrefix?: string;
+    defaultNamespace?: string;
+    transKeepBasicHtmlNodesFor: string[];
+    omitAttributes: string[];
+};
+type FoundKey = {
+    key: string;
+    ns?: string;
+    namespace?: string;
+    functionName?: string;
+    defaultValue?: string;
+    [key: string]: unknown;
+};
+export declare const getKeys: (path: string, options: Partial<Options>, content: string) => FoundKey[];
+export {};

package/dist/utils/i18NextSrcParser.js

@@ -0,0 +1,718 @@
+"use strict";
+/**
+ *
+ * Based on the original [i18next-parser](https://github.com/i18next/i18next-parser)
+ *
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeys = void 0;
+const ts = __importStar(require("typescript"));
+const USE_TRANSLATION = 'useTranslation';
+const WITH_TRANSLATION = 'withTranslation';
+const TRANSLATION_TYPE = 'TFunction';
+const getKeys = (path, options, content) => {
+    const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
+    const defaultOptions = {
+        attr: 'i18nKey',
+        componentFunctions: ['Trans'],
+        functions: ['t'],
+        namespaceFunctions: [USE_TRANSLATION, WITH_TRANSLATION],
+        parseGenerics: false,
+        transSupportBasicHtmlNodes: false,
+        transIdentityFunctionsToIgnore: [],
+        typeMap: {},
+        translationFunctionsWithArgs: {},
+        transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],
+        omitAttributes: ['ns', 'defaults'],
+    };
+    const parserOptions = { ...defaultOptions, ...options };
+    parserOptions.omitAttributes = [
+        parserOptions.attr,
+        ...parserOptions.omitAttributes,
+    ];
+    let foundKeys = [];
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node)) {
+            extractFromVariableDeclaration(node, parserOptions);
+        }
+        if (ts.isCallExpression(node)) {
+            const keys = extractFromExpression(node, parserOptions);
+            if (keys) {
+                foundKeys = foundKeys.concat(keys);
+            }
+        }
+        if (ts.isTaggedTemplateExpression(node)) {
+            const key = extractFromTaggedTemplateExpression(node, parserOptions);
+            if (key) {
+                foundKeys.push(key);
+            }
+        }
+        if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+            const key = extractFromJsx(node, content, parserOptions);
+            if (key) {
+                foundKeys.push(key);
+            }
+        }
+        if (ts.isArrowFunction(node) || ts.isFunctionDeclaration(node)) {
+            extractFromFunction(node, parserOptions);
+        }
+        // Collect all keys defined in comments
+        const commentKeys = [];
+        ts.forEachLeadingCommentRange(content, node.getFullStart(), (pos, end, kind) => {
+            if (kind === ts.SyntaxKind.MultiLineCommentTrivia ||
+                kind === ts.SyntaxKind.SingleLineCommentTrivia) {
+                const text = content.slice(pos, end);
+                const functionPattern = '(?:' + parserOptions.functions.join('|').replace('.', '\\.') + ')';
+                const callPattern = '(?<=^|\\s|\\.)' + functionPattern + '\\(.*\\)';
+                const regexp = new RegExp(callPattern, 'g');
+                const expressions = text.match(regexp);
+                if (!expressions) {
+                    return null;
+                }
+                const foundKeys = [];
+                expressions.forEach((expression) => {
+                    const expressionKeys = (0, exports.getKeys)('', {}, expression);
+                    if (expressionKeys) {
+                        commentKeys.push(...expressionKeys);
+                    }
+                });
+                if (foundKeys) {
+                    commentKeys.push(...foundKeys);
+                }
+            }
+        });
+        if (commentKeys) {
+            commentKeys.forEach((key) => {
+                if (!foundKeys.find((k) => k.key === key.key)) {
+                    foundKeys.push(key);
+                }
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return foundKeys;
+};
+exports.getKeys = getKeys;
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L74
+const extractFromJsx = (node, content, options) => {
+    const tagNode = ts.isJsxElement(node) ? node.openingElement : node;
+    const getKey = (node) => getPropertyValue(node, options.attr);
+    if (options.componentFunctions.includes(expressionToName(tagNode.tagName))) {
+        const entry = { key: getKey(tagNode) ?? '' };
+        const namespace = getPropertyValue(tagNode, 'ns');
+        if (namespace) {
+            entry.namespace = namespace;
+        }
+        tagNode.attributes.properties.forEach((property) => {
+            if (property.kind === ts.SyntaxKind.JsxSpreadAttribute) {
+                return;
+            }
+            const propertyName = property.name.getText();
+            if (options.omitAttributes.includes(propertyName)) {
+                return;
+            }
+            if (property.initializer) {
+                if (ts.isJsxExpression(property.initializer) &&
+                    property.initializer.expression) {
+                    if (property.initializer.expression.kind === ts.SyntaxKind.TrueKeyword) {
+                        entry[propertyName] = true;
+                    }
+                    else if (property.initializer.expression.kind === ts.SyntaxKind.FalseKeyword) {
+                        entry[propertyName] = false;
+                    }
+                    else {
+                        entry[propertyName] = `{${cleanMultiLineCode(content.slice(property.initializer.expression.pos, property.initializer.expression.end))}}`;
+                    }
+                }
+                else if (ts.isStringLiteral(property.initializer)) {
+                    entry[propertyName] = property.initializer.text;
+                }
+            }
+            else {
+                entry[propertyName] = true;
+            }
+        });
+        const nodeAsString = nodeToString(node, content, options);
+        const defaultsProp = getPropertyValue(tagNode, 'defaults');
+        let defaultValue = defaultsProp || nodeAsString;
+        if (entry.shouldUnescape !== true) {
+            defaultValue = unescape(defaultValue);
+        }
+        if (defaultValue !== '') {
+            entry.defaultValue = defaultValue;
+            if (!entry.key) {
+                entry.key = unescape(nodeAsString) || entry.defaultValue || '';
+            }
+        }
+        return entry.key ? entry : null;
+    }
+    else if (tagNode.tagName.getText() === 'Interpolate') {
+        const entry = { key: getKey(tagNode) ?? '' };
+        return entry.key ? entry : null;
+    }
+    else if (tagNode.tagName.getText() === 'Translation') {
+        const namespace = getPropertyValue(tagNode, 'ns');
+        if (namespace) {
+            options.defaultNamespace = namespace;
+        }
+    }
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L77
+const getPropertyValue = (node, attr) => {
+    const attribute = node.attributes.properties.find((attribute) => {
+        return attribute.name !== undefined && attribute.name.getText() === attr;
+    });
+    if (!attribute) {
+        return undefined;
+    }
+    if (!ts.isJsxAttribute(attribute) ||
+        !attribute.initializer ||
+        (ts.isJsxExpression(attribute.initializer) &&
+            attribute.initializer?.expression &&
+            ts.isIdentifier(attribute.initializer?.expression))) {
+        return undefined;
+    }
+    if (ts.isStringLiteral(attribute.initializer)) {
+        return attribute.initializer.text;
+    }
+    if (ts.isJsxExpression(attribute.initializer) &&
+        attribute.initializer?.expression &&
+        (ts.isStringLiteral(attribute.initializer?.expression) ||
+            ts.isNoSubstitutionTemplateLiteral(attribute.initializer.expression))) {
+        return attribute.initializer.expression.text;
+    }
+    return undefined;
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/javascript-lexer.js#L165
+const extractFromTaggedTemplateExpression = (node, options) => {
+    const { tag, template } = node;
+    if (!options.functions.includes(tag.getText()) &&
+        !(ts.isPropertyAccessExpression(tag) &&
+            options.functions.includes(tag.name.text))) {
+        return undefined;
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(template)) {
+        return { key: template.text };
+    }
+    return undefined;
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/javascript-lexer.js#L75
+const extractFromVariableDeclaration = (node, options) => {
+    if (ts.isIdentifier(node.name)) {
+        return undefined;
+    }
+    const [firstElement] = node.name.elements;
+    if (!ts.isBindingElement(firstElement)) {
+        return undefined;
+    }
+    const firstElementName = firstElement?.propertyName ?? firstElement.name;
+    if (hasEscapedText(firstElementName) &&
+        firstElementName?.escapedText === 't' &&
+        hasEscapedText(firstElement.name) &&
+        options.functions.includes(firstElement?.name?.escapedText.toString()) &&
+        node.initializer &&
+        ts.isCallExpression(node.initializer) &&
+        ts.isIdentifier(node.initializer.expression) &&
+        options.namespaceFunctions.includes(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        node.initializer?.expression?.escapedText)) {
+        options.translationFunctionsWithArgs[firstElement.name.escapedText.toString()] = {
+            pos: node.initializer.pos,
+            storeGlobally: !(firstElement.propertyName &&
+                hasEscapedText(firstElement.propertyName) &&
+                firstElement.propertyName?.escapedText),
+        };
+    }
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/javascript-lexer.js#L138
+const extractFromFunction = (node, options) => {
+    const tFnParam = node.parameters &&
+        node.parameters.find((param) => param.name &&
+            ts.isIdentifier(param.name) &&
+            options.functions.includes(param.name.text));
+    if (tFnParam &&
+        tFnParam.type &&
+        ts.isTypeReferenceNode(tFnParam.type) &&
+        tFnParam.type.typeName &&
+        ts.isIdentifier(tFnParam.type.typeName) &&
+        tFnParam.type.typeName.text === TRANSLATION_TYPE) {
+        if (tFnParam.type.typeArguments && tFnParam.type.typeArguments.length > 0) {
+            const [firstArgument] = tFnParam.type.typeArguments;
+            if (ts.isLiteralTypeNode(firstArgument) &&
+                ts.isStringLiteral(firstArgument.literal)) {
+                options.defaultNamespace = firstArgument.literal.text;
+            }
+        }
+    }
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/javascript-lexer.js#L189
+const extractFromExpression = (node, options) => {
+    const entries = [{ key: '' }];
+    const functionDefinition = Object.entries(options.translationFunctionsWithArgs).find(([_name, translationFunc]) => translationFunc?.pos === node.pos);
+    let storeGlobally = functionDefinition?.[1].storeGlobally ?? true;
+    const isNamespaceFunction = (ts.isIdentifier(node.expression) &&
+        node.expression.escapedText &&
+        options.namespaceFunctions.includes(node.expression.escapedText)) ||
+        options.namespaceFunctions.includes(expressionToName(node.expression));
+    if (isNamespaceFunction && node.arguments.length > 0) {
+        storeGlobally =
+            storeGlobally ||
+                (hasEscapedText(node.expression) &&
+                    node.expression.escapedText === WITH_TRANSLATION);
+        const [namespaceArgument, optionsArgument] = node.arguments;
+        const namespaces = ts.isArrayLiteralExpression(namespaceArgument)
+            ? namespaceArgument.elements
+            : [namespaceArgument];
+        const namespace = namespaces.find((namespace) => ts.isStringLiteral(namespace) ||
+            (ts.isIdentifier(namespace) && namespace.text === 'undefined'));
+        if (!namespace) {
+            // No namespace found - technically a warning could be logged here
+        }
+        else if (ts.isStringLiteral(namespace)) {
+            if (storeGlobally) {
+                options.defaultNamespace = namespace.text;
+            }
+            entries[0].ns = namespace.text;
+        }
+        if (optionsArgument && ts.isObjectLiteralExpression(optionsArgument)) {
+            const keyPrefixNode = optionsArgument.properties.find((p) => p.name &&
+                hasEscapedText(p.name) &&
+                p.name?.escapedText === 'keyPrefix');
+            if (keyPrefixNode != null && ts.isPropertyAssignment(keyPrefixNode)) {
+                if (storeGlobally) {
+                    options.keyPrefix = keyPrefixNode.initializer.getText();
+                }
+                entries[0].keyPrefix = keyPrefixNode.initializer.getText();
+            }
+        }
+    }
+    const isTranslationFunction = (ts.isStringLiteral(node.expression) &&
+        node.expression.text &&
+        options.functions.includes(node.expression.text)) ||
+        (hasName(node.expression) &&
+            node.expression.name &&
+            hasText(node.expression.name) &&
+            options.functions.includes(node.expression.name.text)) ||
+        options.functions.includes(expressionToName(node.expression));
+    if (isTranslationFunction) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const keyArgument = node.arguments.shift();
+        if (!keyArgument) {
+            return null;
+        }
+        if (ts.isStringLiteral(keyArgument) ||
+            ts.isNoSubstitutionTemplateLiteral(keyArgument)) {
+            entries[0].key = keyArgument.text;
+        }
+        else if (ts.isBinaryExpression(keyArgument)) {
+            const concatenatedString = concatenateString(keyArgument);
+            if (!concatenatedString) {
+                return null;
+            }
+            entries[0].key = concatenatedString;
+        }
+        else {
+            return null;
+        }
+        if (options.parseGenerics && node.typeArguments) {
+            const nodeTypeArguments = copyNodeArray(node.typeArguments);
+            const typeArgument = nodeTypeArguments.shift();
+            const parseTypeArgument = (typeNode) => {
+                if (!typeNode) {
+                    return;
+                }
+                if (ts.isTypeLiteralNode(typeNode)) {
+                    for (const member of typeNode.members) {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        entries[0][member.name?.text] = '';
+                    }
+                }
+                else if (ts.isTypeReferenceNode(typeNode) &&
+                    ts.isIdentifier(typeNode.typeName)) {
+                    const typeName = typeNode.typeName.text;
+                    if (typeName in options.typeMap) {
+                        Object.assign(entries[0], options.typeMap[typeName]);
+                    }
+                }
+                else if ((ts.isUnionTypeNode(typeNode) ||
+                    ts.isIntersectionTypeNode(typeNode)) &&
+                    Array.isArray(typeNode.types)) {
+                    typeNode.types.forEach((type) => parseTypeArgument(type));
+                }
+            };
+            parseTypeArgument(typeArgument);
+        }
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        let optionsArgument = node.arguments.shift();
+        if (optionsArgument &&
+            (ts.isStringLiteral(optionsArgument) ||
+                ts.isNoSubstitutionTemplateLiteral(optionsArgument))) {
+            entries[0].defaultValue = optionsArgument.text;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            optionsArgument = node.arguments.shift();
+        }
+        else if (optionsArgument && ts.isBinaryExpression(optionsArgument)) {
+            const concatenatedString = concatenateString(optionsArgument);
+            if (!concatenatedString) {
+                return null;
+            }
+            entries[0].defaultValue = concatenatedString;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            optionsArgument = node.arguments.shift();
+        }
+        if (optionsArgument && ts.isObjectLiteralExpression(optionsArgument)) {
+            for (const optionProperty of optionsArgument.properties) {
+                if (ts.isSpreadAssignment(optionProperty)) {
+                    // Skip as this can't be processed. A warning could be logged at some point.
+                }
+                else if (ts.isPropertyAssignment(optionProperty)) {
+                    const propertyName = getNodeText(optionProperty.name);
+                    if (optionProperty.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                        entries[0][propertyName] = true;
+                    }
+                    else if (optionProperty.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                        entries[0][propertyName] = false;
+                    }
+                    else if (ts.isCallExpression(optionProperty.initializer)) {
+                        const nestedEntries = extractFromExpression(optionProperty.initializer, options);
+                        if (nestedEntries) {
+                            entries.push(...nestedEntries);
+                        }
+                        else {
+                            entries[0][propertyName] =
+                                getNodeText(optionProperty.initializer) || '';
+                        }
+                    }
+                    else {
+                        entries[0][propertyName] =
+                            getNodeText(optionProperty.initializer) || '';
+                    }
+                }
+                else {
+                    entries[0][getNodeText(optionProperty.name)] = '';
+                }
+            }
+        }
+        if (entries[0].ns) {
+            if (typeof entries[0].ns === 'string') {
+                entries[0].namespace = entries[0].ns;
+                // Need to double check if this is even needed
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+            }
+            else if (Array.isArray(entries[0].ns) && entries[0].ns.length) {
+                entries[0].namespace = entries[0].ns[0];
+            }
+        }
+        entries[0].functionName = hasEscapedText(node.expression)
+            ? node.expression.escapedText.toString()
+            : node.expression.getText();
+        return entries
+            .map((entry) => {
+            const namespace = entry.ns ??
+                options.translationFunctionsWithArgs?.[entry.functionName ?? '']
+                    ?.ns ??
+                options.defaultNamespace;
+            return namespace
+                ? {
+                    ...entry,
+                    namespace,
+                }
+                : entry;
+        })
+            .map(({ functionName, ...key }) => {
+            const keyPrefix = options.translationFunctionsWithArgs?.[functionName ?? '']
+                ?.keyPrefix ?? options.keyPrefix;
+            return keyPrefix
+                ? {
+                    ...key,
+                    keyPrefix,
+                }
+                : key;
+        });
+    }
+    const isTranslationFunctionCreation = hasEscapedText(node.expression) &&
+        node.expression.escapedText &&
+        options.namespaceFunctions.includes(node.expression.escapedText);
+    if (isTranslationFunctionCreation) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        options.translationFunctionsWithArgs[functionDefinition?.[0] ?? ''] =
+            entries[0];
+    }
+    return null;
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/javascript-lexer.js#L419
+const concatenateString = (binaryExpression, string = '') => {
+    if (!ts.isPlusToken(binaryExpression.operatorToken)) {
+        return;
+    }
+    if (ts.isBinaryExpression(binaryExpression.left)) {
+        string += concatenateString(binaryExpression.left, string);
+    }
+    else if (ts.isStringLiteral(binaryExpression.left)) {
+        string += binaryExpression.left.text;
+    }
+    else {
+        return;
+    }
+    if (ts.isBinaryExpression(binaryExpression.right)) {
+        string += concatenateString(binaryExpression.right, string);
+    }
+    else if (ts.isStringLiteral(binaryExpression.right)) {
+        string += binaryExpression.right.text;
+    }
+    else {
+        return;
+    }
+    return string;
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L186
+const nodeToString = (node, content, options) => {
+    if (ts.isJsxSelfClosingElement(node)) {
+        return '';
+    }
+    const elements = parseElements(node.children, content, options);
+    const elementsToString = (elements) => elements
+        .map((element, index) => {
+        switch (element.type) {
+            case 'js':
+            case 'text':
+                return element.content;
+            case 'tag': {
+                const useTagName = element.isBasic &&
+                    options.transSupportBasicHtmlNodes &&
+                    options.transKeepBasicHtmlNodesFor.includes(element.name);
+                const elementName = useTagName ? element.name : index;
+                const childrenString = elementsToString(element.children);
+                return childrenString || !(useTagName && element.selfClosing)
+                    ? `<${elementName}>${childrenString}</${elementName}>`
+                    : `<${elementName} />`;
+            }
+            default:
+            // Do nothing
+        }
+    })
+        .join('');
+    return elementsToString(elements);
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L226
+const parseElements = (elements, content, options) => {
+    if (!elements) {
+        return [];
+    }
+    return elements
+        .map((elem) => {
+        if (ts.isJsxText(elem)) {
+            return {
+                type: 'text',
+                content: cleanMultiLineCode(elem.text),
+            };
+        }
+        else if (ts.isJsxElement(elem) || ts.isJsxSelfClosingElement(elem)) {
+            const element = ts.isJsxElement(elem) ? elem.openingElement : elem;
+            const name = hasEscapedText(element.tagName)
+                ? element.tagName.escapedText.toString()
+                : element.tagName.getText();
+            const isBasic = !element.attributes.properties.length;
+            const hasDynamicChildren = element.attributes.properties.find((prop) => ts.isJsxAttribute(prop) &&
+                hasEscapedText(prop.name) &&
+                prop.name.escapedText === 'i18nIsDynamicList');
+            return {
+                type: 'tag',
+                children: hasDynamicChildren || !ts.isJsxElement(elem)
+                    ? []
+                    : parseElements(elem.children, content, options),
+                name,
+                isBasic,
+                selfClosing: ts.isJsxSelfClosingElement(elem),
+            };
+        }
+        else if (ts.isJsxExpression(elem)) {
+            if (!elem.expression) {
+                return {
+                    type: 'text',
+                    content: '',
+                };
+            }
+            //Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L265
+            while (hasExpression(elem) &&
+                elem.expression &&
+                ts.isAsExpression(elem.expression)) {
+                elem = elem.expression;
+            }
+            if (hasExpression(elem) &&
+                ts.isCallExpression(elem.expression) &&
+                ts.isIdentifier(elem.expression.expression) &&
+                options.transIdentityFunctionsToIgnore.includes(elem.expression.expression.escapedText.toString()) &&
+                elem.expression.arguments.length >= 1) {
+                // Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L291
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                elem = { expression: elem.expression.arguments[0] };
+            }
+            if (hasExpression(elem) && ts.isStringLiteral(elem.expression)) {
+                return {
+                    type: 'text',
+                    content: elem.expression.text,
+                };
+            }
+            else if (hasExpression(elem) &&
+                ts.isObjectLiteralExpression(elem.expression)) {
+                const nonFormatProperties = elem.expression.properties.filter((prop) => prop.name?.getText() !== 'format');
+                const formatProperty = elem.expression.properties.find((prop) => prop.name?.getText() === 'format');
+                if (nonFormatProperties.length > 1) {
+                    return {
+                        type: 'text',
+                        content: '',
+                    };
+                }
+                const nonFormatPropertyName = nonFormatProperties[0]?.name
+                    ? getNodeText(nonFormatProperties[0].name)
+                    : '';
+                const value = formatProperty && ts.isPropertyAssignment(formatProperty)
+                    ? `${nonFormatPropertyName}, ${getNodeText(formatProperty.initializer)}`
+                    : nonFormatPropertyName;
+                return {
+                    type: 'js',
+                    content: `{{${value}}}`,
+                };
+            }
+            if (hasExpression(elem)) {
+                const slicedExpression = content.slice(elem.expression.pos, elem.expression.end);
+                return {
+                    type: 'js',
+                    content: `{${slicedExpression}}`,
+                };
+            }
+        }
+    })
+        .filter((elem) => elem !== undefined)
+        .filter((elem) => elem.type !== 'text' || elem.content);
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/jsx-lexer.js#L220
+const cleanMultiLineCode = (text) => {
+    return text
+        .replace(/(^(\n|\r)\s*)|((\n|\r)\s*$)/g, '')
+        .replace(/(\n|\r)\s*/g, ' ');
+};
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/lexers/javascript-lexer.js#L447
+const expressionToName = (expression) => {
+    if (!expression) {
+        return '';
+    }
+    if (ts.isStringLiteral(expression) || ts.isIdentifier(expression)) {
+        return expression.text;
+    }
+    else if (hasExpression(expression)) {
+        return [
+            expressionToName(expression.expression),
+            expressionToName(expression.name),
+        ]
+            .filter((s) => s && s.length > 0)
+            .join('.');
+    }
+    return '';
+};
+const hasExpression = (node) => {
+    return ('expression' in node &&
+        !!node.expression &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ts.isExpression(node.expression));
+};
+const hasEscapedText = (node) => {
+    return ts.isIdentifier(node) || ts.isPrivateIdentifier(node);
+};
+const hasName = (node) => {
+    return 'name' in node && node.name !== undefined;
+};
+function hasText(node) {
+    const result = node &&
+        (ts.isStringLiteral(node) ||
+            ts.isNumericLiteral(node) ||
+            ts.isBigIntLiteral(node) ||
+            ts.isNoSubstitutionTemplateLiteral(node) ||
+            ts.isRegularExpressionLiteral(node) ||
+            ts.isIdentifier(node));
+    return result;
+}
+const getNodeText = (node) => {
+    if ('text' in node) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return node.text;
+    }
+    return node.getText();
+};
+const copyNodeArray = (nodes) => {
+    return Array.from(nodes);
+};
+// Uses the original unescape code from i18next-parser
+// to ensure that the found keys reflect the original parser implementation
+// Taken from: https://github.com/i18next/i18next-parser/blob/6c10a2b66ebadb8250039d078ad2a53e52753a6e/src/helpers.js#L317
+const unescape = (text) => {
+    const matchHtmlEntity = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34|nbsp|#160|copy|#169|reg|#174|hellip|#8230|#x2F|#47);/g;
+    const htmlEntities = {
+        '&amp;': '&',
+        '&#38;': '&',
+        '&lt;': '<',
+        '&#60;': '<',
+        '&gt;': '>',
+        '&#62;': '>',
+        '&apos;': "'",
+        '&#39;': "'",
+        '&quot;': '"',
+        '&#34;': '"',
+        '&nbsp;': ' ',
+        '&#160;': ' ',
+        '&copy;': '©',
+        '&#169;': '©',
+        '&reg;': '®',
+        '&#174;': '®',
+        '&hellip;': '…',
+        '&#8230;': '…',
+        '&#x2F;': '/',
+        '&#47;': '/',
+    };
+    const unescapeHtmlEntity = (m) => htmlEntities[m];
+    return text.replace(matchHtmlEntity, unescapeHtmlEntity);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingual/i18n-check",
-  "version": "0.8.18",
+  "version": "0.9.0-beta.1",
   "description": "i18n translation messages check",
   "license": "MIT",
   "main": "dist/index.js",
@@ -28,7 +28,6 @@
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "glob": "12.0.0",
-    "i18next-parser": "^9.3.0",
     "js-yaml": "^4.1.1",
     "typescript": "^5.9.3"
   },
@@ -36,7 +35,6 @@
     "@eslint/js": "^9.39.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.19.1",
-    "@types/vinyl": "^2.0.12",
     "braces": "^3.0.3",
     "eslint": "^9.39.1",
     "globals": "^16.5.0",