feat: support global tolgee.t function call

src/extractor/parser/generalMapper.ts

@@ -113,5 +113,6 @@ export type GeneralTokenType =
   | 'tag.closing'
   | 'tag.attribute.name'
   | 'expression.template.begin'
-  | 'expression.template.end';
+  | 'expression.template.end'
+  | 'trigger.global.t.function';
 export type GeneralToken = Token<GeneralTokenType>;

src/extractor/parser/parser.ts

@@ -21,8 +21,9 @@ import { ExtractOptions, ExtractedKey, Warning } from '../index.js';
 import { stringMerger } from './tokenMergers/stringMerger.js';
 import { templateStringMerger } from './tokenMergers/templateStringMerger.js';
 import { closingTagMerger } from './tokenMergers/closingTagMerger.js';
-import { typesAsMergerer } from './tokenMergers/typesAsMergerer.js';
-import { typesCastMergerer } from './tokenMergers/typesCastMerger.js';
+import { typesAsMerger } from './tokenMergers/typesAsMerger.js';
+import { typesCastMerger } from './tokenMergers/typesCastMerger.js';
+import { customTCallMerger } from './tokenMergers/customTCallMerger.js';
 
 export const DEFAULT_BLOCKS = {
   'block.begin': ['block.end'],
@@ -35,12 +36,13 @@ export const DEFAULT_BLOCKS = {
   ],
 } satisfies BlocksType<GeneralTokenType>;
 
-export const DEFAULT_MERGERERS = [
+export const DEFAULT_MERGERS = [
   stringMerger,
   templateStringMerger,
   closingTagMerger,
-  typesAsMergerer,
-  typesCastMergerer,
+  typesAsMerger,
+  typesCastMerger,
+  customTCallMerger(['tolgee.t']),
 ] as const;
 
 type ParserOptions<T extends string = GeneralTokenType> = {

src/extractor/parser/rules/globalTFunction.ts

@@ -0,0 +1,10 @@
+import { tFunctionGeneral } from './tFunctionGeneral.js';
+import { RuleType } from '../types.js';
+import { GeneralTokenType } from '../generalMapper.js';
+
+export const globalTFunction = {
+  trigger: 'trigger.global.t.function',
+  call(context) {
+    return tFunctionGeneral(context, false);
+  },
+} satisfies RuleType<GeneralTokenType> as any;

src/extractor/parser/tokenMergers/customTCallMerger.ts

@@ -0,0 +1,25 @@
+import { ReactMappedTokenType } from '../../parserReact/ParserReact.js';
+import { MachineType } from '../mergerMachine.js';
+
+export const customTCallMerger = (customExpressions: string[]) => {
+  return {
+    initial: '',
+    step: (state, t, end) => {
+      const type = t.customType;
+      const token = t.token;
+
+      if (type === 'variable' || type === 'function.call') {
+        if (customExpressions.find((e) => e.startsWith(state + token))) {
+          return state + token;
+        }
+      } else if (type === 'acessor.dot') {
+        return state + '.';
+      } else if (state !== '' && type === 'expression.begin') {
+        if (customExpressions.includes(state)) {
+          return end.MERGE_ALL;
+        }
+      }
+    },
+    customType: 'trigger.global.t.function',
+  } as const satisfies MachineType<ReactMappedTokenType, string>;
+};

src/extractor/parser/tokenMergers/typesAsMergerer.ts → src/extractor/parser/tokenMergers/typesAsMerger.ts

@@ -4,7 +4,7 @@ import { ReactMappedTokenType } from '../../parserReact/ParserReact.js';
 const INITIAL_DEPTH = -1;
 
 // in ts files we want to ignore stuff after 'as' `[count as number]`
-export const typesAsMergerer = {
+export const typesAsMerger = {
   initial: INITIAL_DEPTH,
   step: (depth, token, end) => {
     const type = token.customType;

src/extractor/parser/tokenMergers/typesCastMerger.ts

@@ -4,7 +4,7 @@ import { ReactMappedTokenType } from '../../parserReact/ParserReact.js';
 const INITIAL_DEPTH = 0;
 
 // in ts files we want to ignore type casting (<number> count)
-export const typesCastMergerer = {
+export const typesCastMerger = {
   initial: INITIAL_DEPTH,
   step: (depth, token, end) => {
     const type = token.customType;

src/extractor/parserNgx/ParserNgx.ts

@@ -1,5 +1,5 @@
 import { pipeMachines } from '../parser/mergerMachine.js';
-import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERS, Parser } from '../parser/parser.js';
 import { IterableItem, Token } from '../parser/types.js';
 
 import { GeneralTokenType, generalMapper } from '../parser/generalMapper.js';
@@ -13,6 +13,7 @@ import { pipeMerger } from './tokenMergers/pipeMerger.js';
 import { componentWithT } from './rules/componentWithT.js';
 import { translatePipe } from './rules/translatePipe.js';
 import { translateFunction } from './rules/translateFunction.js';
+import { globalTFunction } from '../parser/rules/globalTFunction.js';
 
 const ngxMappers = [ngxMapper, generalMapper];
 
@@ -21,7 +22,7 @@ export type NgxMappedTokenType = NonNullable<
 >;
 
 export const ngxMergers = pipeMachines([
-  ...DEFAULT_MERGERERS,
+  ...DEFAULT_MERGERS,
   componentWithTMerger,
   pipeMerger,
   translateMerger,
@@ -39,7 +40,7 @@ export const ParserNgx = () => {
     blocks: {
       ...DEFAULT_BLOCKS,
     },
-    rules: [componentWithT, translatePipe, translateFunction],
+    rules: [globalTFunction, componentWithT, translatePipe, translateFunction],
     merger: ngxMergers,
     treeTransform: ngxTreeTransform,
   });

src/extractor/parserReact/ParserReact.ts

@@ -1,5 +1,5 @@
 import { pipeMachines } from '../parser/mergerMachine.js';
-import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERS, Parser } from '../parser/parser.js';
 import { IterableItem, Token } from '../parser/types.js';
 
 import { GeneralTokenType, generalMapper } from '../parser/generalMapper.js';
@@ -14,6 +14,7 @@ import { reactCreateElement } from './rules/createElement.js';
 import { tComponent } from './rules/tComponent.js';
 import { tFunction } from './rules/tFunction.js';
 import { useTranslate } from './rules/useTranslate.js';
+import { globalTFunction } from '../parser/rules/globalTFunction.js';
 
 const reactMappers = [generalMapper, reactMapper];
 
@@ -22,7 +23,7 @@ export type ReactMappedTokenType = NonNullable<
 >;
 
 export const reactMergers = pipeMachines([
-  ...DEFAULT_MERGERERS,
+  ...DEFAULT_MERGERS,
   createElementMerger,
   useTranslateMerger,
   tFunctionMerger,
@@ -41,7 +42,13 @@ export const ParserReact = () => {
     blocks: {
       ...DEFAULT_BLOCKS,
     },
-    rules: [reactCreateElement, tComponent, tFunction, useTranslate],
+    rules: [
+      globalTFunction,
+      reactCreateElement,
+      tComponent,
+      tFunction,
+      useTranslate,
+    ],
     merger: reactMergers,
   });
 };

src/extractor/parserSvelte/ParserSvelte.ts

@@ -1,5 +1,5 @@
 import { pipeMachines } from '../parser/mergerMachine.js';
-import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERS, Parser } from '../parser/parser.js';
 import { IterableItem, Token } from '../parser/types.js';
 import { svelteMapper } from './svelteMapper.js';
 import { GeneralTokenType, generalMapper } from '../parser/generalMapper.js';
@@ -15,6 +15,7 @@ import { tComponent } from './rules/tComponent.js';
 import { scriptTag } from './rules/scriptTag.js';
 
 import { svelteTreeTransform } from './svelteTreeTransform.js';
+import { globalTFunction } from '../parser/rules/globalTFunction.js';
 
 const svelteMappers = [generalMapper, svelteMapper];
 
@@ -23,7 +24,7 @@ export type SvelteMappedTokenType = NonNullable<
 >;
 
 export const svelteMergers = pipeMachines([
-  ...DEFAULT_MERGERERS,
+  ...DEFAULT_MERGERS,
   tFunctionMerger,
   getTranslateMerger,
   tComponentMerger,
@@ -42,7 +43,7 @@ export const ParserSvelte = () => {
     blocks: {
       ...DEFAULT_BLOCKS,
     },
-    rules: [tFunction, getTranslate, tComponent, scriptTag],
+    rules: [globalTFunction, tFunction, getTranslate, tComponent, scriptTag],
     treeTransform: svelteTreeTransform,
     merger: svelteMergers,
   });

src/extractor/parserVue/ParserVue.ts

@@ -1,24 +1,24 @@
 import { pipeMachines } from '../parser/mergerMachine.js';
-import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERS, Parser } from '../parser/parser.js';
 import { IterableItem, Token } from '../parser/types.js';
 import { GeneralTokenType, generalMapper } from '../parser/generalMapper.js';
 import { vueMapper } from './vueMapper.js';
 import { vueTreeTransform } from './vueTreeTransform.js';
 
-import { globalTFunctionMerger } from './tokenMergers/globalTFunctionMerger.js';
 import { tFunctionMerger } from './tokenMergers/tFunctionMerger.js';
 import { useTranslateMerger } from './tokenMergers/useTranslateMerger.js';
 import { exportDefaultObjectMerger } from './tokenMergers/exportDefaultObjectMerger.js';
 import { scriptTagMerger } from './tokenMergers/scriptTagMerger.js';
 import { tComponentMerger } from './tokenMergers/tComponentMerger.js';
 
-import { globalTFunction } from './rules/globalTFunction.js';
+import { globalTFunction } from '../parser/rules/globalTFunction.js';
 import { tFunction } from './rules/tFunction.js';
 import { useTranslate } from './rules/useTranslate.js';
 import { tComponent } from './rules/tComponent.js';
 import { scriptTag } from './rules/scriptTag.js';
 import { exportDefaultObject } from './rules/exportDefaultObject.js';
 import { hyphenPropsMerger } from './tokenMergers/hyphenPropsMerger.js';
+import { customTCallMerger } from '../parser/tokenMergers/customTCallMerger.js';
 
 const vueMappers = [generalMapper, vueMapper];
 
@@ -27,9 +27,9 @@ export type VueMappedTokenType = NonNullable<
 >;
 
 export const vueMergers = pipeMachines([
-  ...DEFAULT_MERGERERS,
+  ...DEFAULT_MERGERS,
   hyphenPropsMerger,
-  globalTFunctionMerger,
+  customTCallMerger(['$t', 'this.$t']),
   tFunctionMerger,
   useTranslateMerger,
   tComponentMerger,

test/unit/extractor/ngx/translateService.test.ts

@@ -157,4 +157,17 @@ describe('translate service', () => {
       expect(extracted.warnings).toEqual(expectedWarnings);
     });
   });
+
+  describe('global tolgee.t function', () => {
+    it('detects global tolgee.t function', async () => {
+      const code = `
+        const tolgee = Tolgee()
+        tolgee.t('key_name')
+      `;
+
+      const extracted = await extractNgxKeys(code, 'test.ts');
+      expect(extracted.keys).toEqual([{ keyName: 'key_name', line: 3 }]);
+      expect(extracted.warnings).toEqual([]);
+    });
+  });
 });

test/unit/extractor/react/useTranslate.test.ts

@@ -536,4 +536,17 @@ describe.each(['js', 'ts', 'jsx', 'tsx'])('useTranslate (.%s)', (ext) => {
       expect(extracted.keys).toEqual(expectedKeys);
     });
   });
+
+  describe('global tolgee.t function', () => {
+    it('detects global tolgee.t function', async () => {
+      const code = `
+        const tolgee = Tolgee()
+        tolgee.t('key_name')
+      `;
+
+      const extracted = await extractReactKeys(code, FILE_NAME);
+      expect(extracted.keys).toEqual([{ keyName: 'key_name', line: 3 }]);
+      expect(extracted.warnings).toEqual([]);
+    });
+  });
 });

test/unit/extractor/svelte/getTranslate.test.ts

@@ -394,4 +394,19 @@ describe('getTranslate', () => {
       expect(extracted.keys).toEqual(expectedKeys);
     });
   });
+
+  describe('global tolgee.t function', () => {
+    it('detects global tolgee.t function', async () => {
+      const code = `
+        <script>
+          const tolgee = Tolgee()
+          tolgee.t('key_name')
+        </script>
+      `;
+
+      const extracted = await extractSvelteKeys(code, 'App.svelte');
+      expect(extracted.keys).toEqual([{ keyName: 'key_name', line: 4 }]);
+      expect(extracted.warnings).toEqual([]);
+    });
+  });
 });

test/unit/extractor/vue/globalT.test.ts

@@ -70,14 +70,15 @@ describe('$t', () => {
     expect(extracted.keys).toEqual([{ keyName: 'key1', line: 3 }]);
   });
 
-  it('extracts both this.$t and $t', async () => {
+  it('extracts both this.$t and $t but nothing else', async () => {
     const code = `
       <script>
         export default {
           methods: {
             onClick () {
               alert(this.$t('key1'))
               alert($t('key2'))
+              alert(foo.$t('key3'))
             }
           }
         }
@@ -273,4 +274,19 @@ describe('$t', () => {
       expect(extracted.keys).toEqual([]);
     });
   });
+
+  describe('global tolgee.t function', () => {
+    it('detects global tolgee.t function', async () => {
+      const code = `
+        <script>
+          const tolgee = Tolgee()
+          tolgee.t('key_name')
+        </script>
+      `;
+
+      const extracted = await extractVueKeys(code, 'App.vue');
+      expect(extracted.keys).toEqual([{ keyName: 'key_name', line: 4 }]);
+      expect(extracted.warnings).toEqual([]);
+    });
+  });
 });