front: extract keys with TypeScript

Depends on i18next/react-i18next#1842

Signed-off-by: Simon Ser <[email protected]>

Author: emersion

front/scripts/foo.ts

@@ -0,0 +1,135 @@
+import * as ts from 'typescript';
+import path from 'node:path';
+
+const tsconfigPath = ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json');
+const tsconfigFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+const tsconfig = ts.parseJsonConfigFileContent(
+  tsconfigFile.config,
+  ts.sys,
+  path.dirname(tsconfigPath)
+);
+
+const program = ts.createProgram({
+  options: tsconfig.options,
+  rootNames: tsconfig.fileNames,
+  projectReferences: tsconfig.projectReferences,
+});
+const checker = program.getTypeChecker();
+//console.log(checker);
+
+const files = program.getSourceFiles();
+
+const extractedKeys = new Set();
+
+function visitCallExpression(file, node: ts.Node) {
+  const symbol = checker.getSymbolAtLocation(node.expression);
+  if (!symbol) {
+    return;
+  }
+
+  const type = checker.getTypeOfSymbolAtLocation(symbol, node.expression);
+  if (type.symbol?.escapedName !== 'TFunction') {
+    return;
+  }
+
+  //console.log(node.expression.escapedText);
+  //console.log(checker.typeToString(type));
+  //console.log(type.symbol?.escapedName);
+
+  //if (node.expression.escapedText !== 't') {
+  //  console.log('A', file.fileName, file.getLineAndCharacterOfPosition(node.pos));
+  //}
+
+  if (type.resolvedTypeArguments.length !== 2) {
+    throw new Error('Expected two generic type arguments for TFunction');
+  }
+  if (node.arguments.length < 1) {
+    throw new Error('Expected at least one argument for TFunction');
+  }
+
+  const namespaceType = type.resolvedTypeArguments[0];
+  const prefixType = type.resolvedTypeArguments[1];
+
+  let namespaces;
+  if (typeof namespaceType.value === 'string') {
+    namespaces = [namespaceType.value];
+  } else if (checker.isTupleType(namespaceType)) {
+    namespaces = namespaceType.resolvedTypeArguments.map((type) => {
+      return type.value;
+    }).filter((value) => typeof value === 'string');
+    if (namespaceType.resolvedTypeArguments.length !== namespaces.length) {
+      //console.log('C', file.fileName, file.getLineAndCharacterOfPosition(node.pos));
+      //console.log(namespaceType.resolvedTypeArguments.map(checker.typeToString));
+      //console.log(ts.Debug.formatSyntaxKind(symbol.valueDeclaration.kind));
+      //return;
+    }
+    if (namespaces.length === 0) {
+      return;
+    }
+  } else {
+    //console.log('B', file.fileName, file.getLineAndCharacterOfPosition(node.pos));
+    //console.log(checker.typeToString(namespaceType));
+    return;
+  }
+
+  if (typeof prefixType.value !== 'string' && prefixType !== checker.getUndefinedType()) {
+    //console.log('D', file.fileName, file.getLineAndCharacterOfPosition(node.pos));
+    //console.log(type.resolvedTypeArguments.map(checker.typeToString));
+    //console.log(type.resolvedTypeArguments.map((t) => t.value));
+    //console.log(namespaceType);
+    return;
+  }
+
+  const prefix = prefixType.value;
+
+  const keyNode = node.arguments[0];
+  let key;
+  if (ts.isStringLiteral(keyNode)) {
+    key = keyNode.text;
+  } else {
+    const symbol = checker.getSymbolAtLocation(keyNode);
+    const type = symbol ? checker.getTypeOfSymbol(symbol) : null;
+    if (!ts.isTemplateExpression(keyNode)) {
+      //console.log('E', file.fileName, file.getLineAndCharacterOfPosition(node.pos));
+      //console.log(ts.Debug.formatSyntaxKind(keyNode.kind));
+      //console.log(type);
+    }
+    return;
+  }
+
+  // TODO: extract ns from TFunction options, if any
+
+  //console.log(namespaces, prefix, key);
+
+  if (!key.includes(':')) {
+    if (prefix) {
+      key = prefix + '.' + key;
+    }
+    key = namespaces[0] + ':' + key;
+  }
+
+  extractedKeys.add(key);
+}
+
+function visitNode(file, node: ts.Node) {
+  if (ts.isCallExpression(node)) {
+    visitCallExpression(file, node);
+  }
+
+  //if (ts.isCallExpression(node) && node.expression?.name?.escapedText === 't') {
+    //console.log(file.fileName, file.getLineAndCharacterOfPosition(node.pos));
+    //console.log(node);
+    //console.log(checker.getSymbolAtLocation(node.expression));
+    //console.log('');
+  //}
+
+  node.forEachChild((node) => visitNode(file, node));
+}
+
+for (const file of files) {
+  //console.log(file);
+
+  visitNode(file, file);
+}
+
+console.log(extractedKeys.size);