@lingual/i18n-check 0.9.0 → 0.9.2

package/dist/utils/nextIntlSrcParser.d.ts

@@ -0,0 +1,8 @@
+export declare const extract: (filesPaths: string[]) => {
+    key: string;
+    meta: {
+        file: string;
+        namespace?: string;
+        dynamic?: boolean;
+    };
+}[];

package/dist/utils/nextIntlSrcParser.js

@@ -0,0 +1,432 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const ts = __importStar(require("typescript"));
+const USE_TRANSLATIONS = 'useTranslations';
+const GET_TRANSLATIONS = 'getTranslations';
+const COMMENT_CONTAINS_STATIC_KEY_REGEX = /i18n-check t\((["'])(.*?[^\\])(["'])\)/;
+const extract = (filesPaths) => {
+    return filesPaths.flatMap(getKeys).sort((a, b) => {
+        return a.key > b.key ? 1 : -1;
+    });
+};
+exports.extract = extract;
+const getKeys = (path) => {
+    const content = node_fs_1.default.readFileSync(path, 'utf-8');
+    const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
+    const foundKeys = [];
+    let namespaces = [];
+    const getCurrentNamespaces = (range = 1) => {
+        if (namespaces.length > 0) {
+            return namespaces.slice(namespaces.length - range);
+        }
+        return null;
+    };
+    const getCurrentNamespaceForIdentifier = (name) => {
+        return [...namespaces].reverse().find((namespace) => {
+            return namespace.variable === name;
+        });
+    };
+    const pushNamespace = (namespace) => {
+        namespaces.push(namespace);
+    };
+    const setNamespaceAsDynamic = (name) => {
+        namespaces = namespaces.map((namespace) => {
+            if (namespace.name === name) {
+                return { ...namespace, dynamic: true };
+            }
+            return namespace;
+        });
+    };
+    const removeNamespaces = (range = 1) => {
+        if (namespaces.length > 0) {
+            namespaces = namespaces.slice(0, namespaces.length - range);
+        }
+    };
+    const visit = (node) => {
+        let key = null;
+        const initialNamespacesLength = namespaces.length;
+        if (node === undefined) {
+            return;
+        }
+        if (ts.isVariableDeclaration(node)) {
+            if (node.initializer && ts.isCallExpression(node.initializer)) {
+                if (ts.isIdentifier(node.initializer.expression)) {
+                    // Search for `useTranslations` calls and extract the namespace
+                    // Additionally check for assigned variable name, as it might differ
+                    // from the default `t`, i.e.: const other = useTranslations("namespace1");
+                    if (node.initializer.expression.text === USE_TRANSLATIONS) {
+                        const [argument] = node.initializer.arguments;
+                        const variable = ts.isIdentifier(node.name) ? node.name.text : 't';
+                        if (argument && ts.isStringLiteral(argument)) {
+                            pushNamespace({ name: argument.text, variable });
+                        }
+                        else if (argument === undefined) {
+                            pushNamespace({ name: '', variable });
+                        }
+                    }
+                }
+            }
+            // Search for `getTranslations` calls and extract the namespace
+            // There are two different ways `getTranslations` can be used:
+            //
+            // import {getTranslations} from 'next-intl/server';
+            // const t = await getTranslations(namespace?);
+            // const t = await getTranslations({locale, namespace});
+            //
+            // Additionally check for assigned variable name, as it might differ
+            // from the default `t`, i.e.: const other = getTranslations("namespace1");
+            // Simplified usage in async components
+            if (node.initializer && ts.isAwaitExpression(node.initializer)) {
+                if (ts.isCallExpression(node.initializer.expression) &&
+                    ts.isIdentifier(node.initializer.expression.expression)) {
+                    if (node.initializer.expression.expression.text === GET_TRANSLATIONS) {
+                        const [argument] = node.initializer.expression.arguments;
+                        const variable = ts.isIdentifier(node.name) ? node.name.text : 't';
+                        if (argument && ts.isObjectLiteralExpression(argument)) {
+                            argument.properties.forEach((property) => {
+                                if (property &&
+                                    ts.isPropertyAssignment(property) &&
+                                    property.name &&
+                                    ts.isIdentifier(property.name) &&
+                                    property.name.text === 'namespace' &&
+                                    ts.isStringLiteral(property.initializer)) {
+                                    pushNamespace({ name: property.initializer.text, variable });
+                                }
+                                else {
+                                    pushNamespace({ name: '', variable });
+                                }
+                            });
+                        }
+                        else if (argument && ts.isStringLiteral(argument)) {
+                            pushNamespace({ name: argument.text, variable });
+                        }
+                        else if (argument === undefined) {
+                            pushNamespace({ name: '', variable });
+                        }
+                    }
+                }
+                // Check if getTranslations is called inside a promise.all
+                // Example:
+                // const [data, t] = await Promise.all([
+                //    loadData(id),
+                //    getTranslations('asyncPromiseAll'),
+                // ]);
+                if (ts.isCallExpression(node.initializer.expression) &&
+                    node.initializer.expression.arguments.length > 0 &&
+                    ts.isArrayLiteralExpression(node.initializer.expression.arguments[0])) {
+                    const functionNameIndex = node.initializer.expression.arguments[0].elements.findIndex((argument) => {
+                        return (ts.isCallExpression(argument) &&
+                            ts.isIdentifier(argument.expression) &&
+                            argument.expression.text === GET_TRANSLATIONS);
+                    });
+                    // Try to find the correct function name via the position in the variable declaration
+                    if (functionNameIndex !== -1 &&
+                        ts.isArrayBindingPattern(node.name) &&
+                        ts.isBindingElement(node.name.elements[functionNameIndex]) &&
+                        ts.isIdentifier(node.name.elements[functionNameIndex].name)) {
+                        const variable = node.name.elements[functionNameIndex].name.text;
+                        const [argument] = ts.isCallExpression(node.initializer.expression.arguments[0].elements[functionNameIndex])
+                            ? node.initializer.expression.arguments[0].elements[functionNameIndex].arguments
+                            : [];
+                        if (argument && ts.isObjectLiteralExpression(argument)) {
+                            argument.properties.forEach((property) => {
+                                if (property &&
+                                    ts.isPropertyAssignment(property) &&
+                                    property.name &&
+                                    ts.isIdentifier(property.name) &&
+                                    property.name.text === 'namespace' &&
+                                    ts.isStringLiteral(property.initializer)) {
+                                    pushNamespace({ name: property.initializer.text, variable });
+                                }
+                            });
+                        }
+                        else if (argument && ts.isStringLiteral(argument)) {
+                            pushNamespace({ name: argument.text, variable });
+                        }
+                        else if (argument === undefined) {
+                            pushNamespace({ name: '', variable });
+                        }
+                    }
+                }
+            }
+        }
+        // Search for direct inline calls and extract namespace and key
+        //
+        // useTranslations("ns1")("one")
+        // useTranslations("ns1").rich("one");
+        // useTranslations("ns1").raw("one");
+        if (ts.isExpressionStatement(node)) {
+            let inlineNamespace = null;
+            if (node.expression && ts.isCallExpression(node.expression)) {
+                // Search: useTranslations("ns1")("one")
+                if (ts.isCallExpression(node.expression.expression) &&
+                    ts.isIdentifier(node.expression.expression.expression)) {
+                    if (node.expression.expression.expression.text === USE_TRANSLATIONS) {
+                        const [argument] = node.expression.expression.arguments;
+                        if (argument && ts.isStringLiteral(argument)) {
+                            inlineNamespace = argument.text;
+                        }
+                    }
+                }
+                // Search: useTranslations("ns1").*("one")
+                if (ts.isPropertyAccessExpression(node.expression.expression) &&
+                    ts.isCallExpression(node.expression.expression.expression) &&
+                    ts.isIdentifier(node.expression.expression.expression.expression)) {
+                    if (node.expression.expression.expression.expression.text ===
+                        USE_TRANSLATIONS) {
+                        const [argument] = node.expression.expression.expression.arguments;
+                        if (argument && ts.isStringLiteral(argument)) {
+                            inlineNamespace = argument.text;
+                        }
+                        const [callArgument] = node.expression.arguments;
+                        if (callArgument && ts.isStringLiteral(callArgument)) {
+                            const key = callArgument.text;
+                            if (key) {
+                                foundKeys.push({
+                                    key: inlineNamespace ? `${inlineNamespace}.${key}` : key,
+                                    meta: { file: path, namespace: inlineNamespace ?? undefined },
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Check if a function has the t function as a parameter
+        // and if a namespace can be extracted from it
+        if (ts.isFunctionLike(node)) {
+            // The first scenario is the t function is defined as:
+            //  someFn(t: ReturnType<typeof useTranslations<'someNamespace'>>)
+            const tFunctionParam = node.parameters &&
+                node.parameters.find((param) => param.type &&
+                    ts.isTypeReferenceNode(param.type) &&
+                    param.type.typeName &&
+                    ts.isIdentifier(param.type.typeName) &&
+                    param.type.typeName.text === 'ReturnType' &&
+                    param.type.typeArguments &&
+                    param.type.typeArguments.length > 0 &&
+                    ts.isTypeQueryNode(param.type.typeArguments[0]) &&
+                    ts.isIdentifier(param.type.typeArguments[0].exprName) &&
+                    param.type.typeArguments[0].exprName.text === USE_TRANSLATIONS);
+            if (tFunctionParam !== undefined &&
+                tFunctionParam.type &&
+                ts.isTypeReferenceNode(tFunctionParam.type) &&
+                tFunctionParam.type.typeArguments &&
+                tFunctionParam.type.typeArguments.length > 0 &&
+                ts.isTypeQueryNode(tFunctionParam.type.typeArguments[0]) &&
+                ts.isIdentifier(tFunctionParam.type.typeArguments[0].exprName) &&
+                tFunctionParam.type.typeArguments[0].exprName.text === USE_TRANSLATIONS) {
+                const [namespaceArgument] = tFunctionParam.type.typeArguments[0].typeArguments &&
+                    tFunctionParam.type.typeArguments[0].typeArguments.length > 0
+                    ? tFunctionParam.type.typeArguments[0].typeArguments
+                    : [];
+                if (ts.isIdentifier(tFunctionParam.name)) {
+                    const name = namespaceArgument &&
+                        ts.isLiteralTypeNode(namespaceArgument) &&
+                        ts.isStringLiteral(namespaceArgument.literal)
+                        ? namespaceArgument.literal.text
+                        : '';
+                    pushNamespace({
+                        name,
+                        variable: tFunctionParam.name.text,
+                    });
+                }
+            }
+            // The second scenario is the t function is defined as an object property:
+            // someFn({t}: {t: ReturnType<typeof useTranslations<'someNamespace'>>}>
+            const tFunctionParamAsProperty = node.parameters &&
+                node.parameters.find((param) => param.type &&
+                    ts.isTypeLiteralNode(param.type) &&
+                    param.type.members.find((member) => {
+                        return (ts.isPropertySignature(member) &&
+                            member.type &&
+                            ts.isTypeReferenceNode(member.type) &&
+                            member.type.typeName &&
+                            ts.isIdentifier(member.type.typeName) &&
+                            member.type.typeName.text === 'ReturnType' &&
+                            member.type.typeArguments &&
+                            member.type.typeArguments.length > 0 &&
+                            ts.isTypeQueryNode(member.type.typeArguments[0]) &&
+                            ts.isIdentifier(member.type.typeArguments[0].exprName) &&
+                            member.type.typeArguments[0].exprName.text === USE_TRANSLATIONS);
+                    }));
+            if (tFunctionParamAsProperty !== undefined &&
+                tFunctionParamAsProperty.type &&
+                ts.isTypeLiteralNode(tFunctionParamAsProperty.type)) {
+                const fnType = tFunctionParamAsProperty.type.members.find((member) => {
+                    return (ts.isPropertySignature(member) &&
+                        member.type &&
+                        ts.isTypeReferenceNode(member.type) &&
+                        member.type.typeName &&
+                        ts.isIdentifier(member.type.typeName) &&
+                        member.type.typeName.text === 'ReturnType' &&
+                        member.type.typeArguments &&
+                        member.type.typeArguments.length > 0 &&
+                        ts.isTypeQueryNode(member.type.typeArguments[0]) &&
+                        ts.isIdentifier(member.type.typeArguments[0].exprName) &&
+                        member.type.typeArguments[0].exprName.text === USE_TRANSLATIONS);
+                });
+                if (fnType &&
+                    ts.isPropertySignature(fnType) &&
+                    fnType.type &&
+                    ts.isTypeReferenceNode(fnType.type) &&
+                    fnType.type.typeArguments &&
+                    fnType.type.typeArguments.length > 0 &&
+                    ts.isTypeQueryNode(fnType.type.typeArguments[0])) {
+                    const [namespaceArgument] = fnType.type.typeArguments[0].typeArguments &&
+                        fnType.type.typeArguments[0].typeArguments.length > 0
+                        ? fnType.type.typeArguments[0].typeArguments
+                        : [];
+                    if (fnType.name && ts.isIdentifier(fnType.name)) {
+                        const name = namespaceArgument &&
+                            ts.isLiteralTypeNode(namespaceArgument) &&
+                            ts.isStringLiteral(namespaceArgument.literal)
+                            ? namespaceArgument.literal.text
+                            : '';
+                        pushNamespace({
+                            name,
+                            variable: fnType.name.text,
+                        });
+                    }
+                }
+            }
+        }
+        // Search for `t()` calls
+        if (getCurrentNamespaces() !== null &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression)) {
+            const expressionName = node.expression.text;
+            const namespace = getCurrentNamespaceForIdentifier(expressionName);
+            if (namespace) {
+                const [argument] = node.arguments;
+                if (argument && ts.isStringLiteral(argument)) {
+                    key = { name: argument.text, identifier: expressionName };
+                }
+                else if (argument && ts.isIdentifier(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
+                }
+                else if (argument && ts.isTemplateExpression(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
+                }
+            }
+        }
+        // Search for `t.*()` calls, i.e. t.html() or t.rich()
+        if (getCurrentNamespaces() !== null &&
+            ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            ts.isIdentifier(node.expression.expression)) {
+            const expressionName = node.expression.expression.text;
+            const namespace = getCurrentNamespaceForIdentifier(expressionName);
+            if (namespace) {
+                const [argument] = node.arguments;
+                if (argument && ts.isStringLiteral(argument)) {
+                    key = { name: argument.text, identifier: expressionName };
+                }
+                else if (argument && ts.isIdentifier(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
+                }
+                else if (argument && ts.isTemplateExpression(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
+                }
+            }
+        }
+        if (key) {
+            const namespace = getCurrentNamespaceForIdentifier(key.identifier);
+            const namespaceName = namespace ? namespace.name : '';
+            foundKeys.push({
+                key: namespaceName ? `${namespaceName}.${key.name}` : key.name,
+                meta: { file: path, namespace: namespaceName },
+            });
+        }
+        // Search for single-line comments that contain the static values of a dynamic key
+        // Example:
+        // const someKeys = messages[selectedOption];
+        // Define as a single-line comment all the possible static keys for that dynamic key
+        // i18n-check t('some.static.key.we.want.to.extract');
+        // i18n-check t('some.other.key.we.want.to.extract.without.semicolons')
+        const commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.getFullStart());
+        if (commentRanges?.length && commentRanges.length > 0) {
+            commentRanges.forEach((range) => {
+                const comment = sourceFile.getFullText().slice(range.pos, range.end);
+                // parse the string and check if it includes the following format:
+                // i18n-check t('someString')
+                const hasStaticKeyComment = COMMENT_CONTAINS_STATIC_KEY_REGEX.test(comment);
+                if (hasStaticKeyComment) {
+                    // capture the string comment
+                    const commentKey = COMMENT_CONTAINS_STATIC_KEY_REGEX.exec(comment)?.[2];
+                    if (commentKey) {
+                        const namespace = getCurrentNamespaces();
+                        const namespaceName = namespace ? namespace[0]?.name : '';
+                        const key = namespaceName
+                            ? `${namespaceName}.${commentKey}`
+                            : commentKey;
+                        const keyExists = foundKeys.find((foundKey) => {
+                            return foundKey.key === key;
+                        });
+                        if (!keyExists) {
+                            foundKeys.push({
+                                key,
+                                meta: { file: path, namespace: namespaceName },
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, visit);
+        if (ts.isFunctionLike(node) &&
+            namespaces.length > initialNamespacesLength) {
+            // check if the namespaces are dynamic and add a placeholder key
+            const currentNamespaces = getCurrentNamespaces(namespaces?.length - initialNamespacesLength);
+            currentNamespaces?.forEach((namespace) => {
+                if (namespace.dynamic) {
+                    foundKeys.push({
+                        key: namespace.name,
+                        meta: { file: path, namespace: namespace.name, dynamic: true },
+                    });
+                }
+            });
+            removeNamespaces(namespaces.length - initialNamespacesLength);
+        }
+    };
+    ts.forEachChild(sourceFile, visit);
+    return foundKeys;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingual/i18n-check",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "i18n translation messages check",
   "license": "MIT",
   "main": "dist/index.js",
@@ -16,7 +16,8 @@
     "lint:fix": "eslint src --fix ",
     "check-format": "prettier --check './{src,translations}/**/*.{js,jsx,ts,tsx,json,html,css}'",
     "test": "vitest run",
-    "test:cli": "pnpm build && vitest --config vitest.bin.config.ts run src/bin/index.test.ts"
+    "test:cli": "pnpm build && vitest --config vitest.bin.config.ts run src/bin/index.test.ts",
+    "prepublishOnly": "pnpm install --frozen-lockfile && pnpm run build"
   },
   "files": [
     "dist/",