@tolgee/cli 2.10.1 → 2.11.0

package/dist/client/ApiClient.js

@@ -11,7 +11,7 @@ import createClient from 'openapi-fetch';
 import base32Decode from 'base32-decode';
 import { API_KEY_PAK_PREFIX, USER_AGENT } from '../constants.js';
 import { getApiKeyInformation } from './getApiKeyInformation.js';
-import { debug } from '../utils/logger.js';
+import { debug, isDebugEnabled } from '../utils/logger.js';
 import { errorFromLoadable } from './errorFromLoadable.js';
 function parseResponse(response, parseAs) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -62,7 +62,18 @@ export function createApiClient({ baseUrl, apiKey, projectId, autoThrow = false,
             debug(`[HTTP] Requesting: ${request.method} ${request.url}`);
         },
         onResponse: (_a) => __awaiter(this, [_a], void 0, function* ({ response, options }) {
-            debug(`[HTTP] Response: ${response.url} [${response.status}]`);
+            let responseText = `[HTTP] Response: ${response.url} [${response.status}]`;
+            const apiVersion = response.headers.get('x-tolgee-version');
+            if (apiVersion) {
+                responseText += ` [${response.headers.get('x-tolgee-version')}]`;
+            }
+            if (!response.ok && isDebugEnabled()) {
+                const clonedBody = yield response.clone().text();
+                if (clonedBody) {
+                    responseText += ` [${clonedBody}]`;
+                }
+            }
+            debug(responseText);
             if (autoThrow && !response.ok) {
                 const loadable = yield parseResponse(response, options.parseAs);
                 throw new Error(`Tolgee request error ${response.url} ${errorFromLoadable(loadable)}`);

package/dist/extractor/parser/parser.js

@@ -7,8 +7,9 @@ import { createMachine } from './mergerMachine.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'],
     'expression.begin': ['expression.end'],
@@ -19,12 +20,13 @@ export const DEFAULT_BLOCKS = {
         'tag.closing.begin',
     ],
 };
-export const DEFAULT_MERGERERS = [
+export const DEFAULT_MERGERS = [
     stringMerger,
     templateStringMerger,
     closingTagMerger,
-    typesAsMergerer,
-    typesCastMergerer,
+    typesAsMerger,
+    typesCastMerger,
+    customTCallMerger(['tolgee.t']),
 ];
 export const Parser = ({ mappers, blocks, rules, merger, treeTransform, }) => {
     const ruleMap = new Map();

package/dist/extractor/{parserVue → parser}/rules/globalTFunction.js

@@ -1,4 +1,4 @@
-import { tFunctionGeneral } from '../../parser/rules/tFunctionGeneral.js';
+import { tFunctionGeneral } from './tFunctionGeneral.js';
 export const globalTFunction = {
     trigger: 'trigger.global.t.function',
     call(context) {

package/dist/extractor/parser/tokenMergers/customTCallMerger.js

@@ -0,0 +1,23 @@
+export const customTCallMerger = (customExpressions) => {
+    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',
+    };
+};

package/dist/extractor/parser/tokenMergers/{typesAsMergerer.js → typesAsMerger.js}

@@ -1,6 +1,6 @@
 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;

package/dist/extractor/parser/tokenMergers/typesCastMerger.js

@@ -1,6 +1,6 @@
 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;

package/dist/extractor/parserNgx/ParserNgx.js

@@ -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 { generalMapper } from '../parser/generalMapper.js';
 import { ngxMapper } from './ngxMapper.js';
 import { ngxTreeTransform } from './ngxTreeTransform.js';
@@ -9,9 +9,10 @@ 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];
 export const ngxMergers = pipeMachines([
-    ...DEFAULT_MERGERERS,
+    ...DEFAULT_MERGERS,
     componentWithTMerger,
     pipeMerger,
     translateMerger,
@@ -20,7 +21,7 @@ export const ParserNgx = () => {
     return Parser({
         mappers: ngxMappers,
         blocks: Object.assign({}, DEFAULT_BLOCKS),
-        rules: [componentWithT, translatePipe, translateFunction],
+        rules: [globalTFunction, componentWithT, translatePipe, translateFunction],
         merger: ngxMergers,
         treeTransform: ngxTreeTransform,
     });

package/dist/extractor/parserReact/ParserReact.js

@@ -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 { generalMapper } from '../parser/generalMapper.js';
 import { reactMapper } from './jsxMapper.js';
 import { createElementMerger } from './tokenMergers/createElementMerger.js';
@@ -10,9 +10,10 @@ 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];
 export const reactMergers = pipeMachines([
-    ...DEFAULT_MERGERERS,
+    ...DEFAULT_MERGERS,
     createElementMerger,
     useTranslateMerger,
     tFunctionMerger,
@@ -22,7 +23,13 @@ export const ParserReact = () => {
     return Parser({
         mappers: reactMappers,
         blocks: Object.assign({}, DEFAULT_BLOCKS),
-        rules: [reactCreateElement, tComponent, tFunction, useTranslate],
+        rules: [
+            globalTFunction,
+            reactCreateElement,
+            tComponent,
+            tFunction,
+            useTranslate,
+        ],
         merger: reactMergers,
     });
 };

package/dist/extractor/parserSvelte/ParserSvelte.js

@@ -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 { svelteMapper } from './svelteMapper.js';
 import { generalMapper } from '../parser/generalMapper.js';
 import { tFunctionMerger } from './tokenMergers/tFunctionMerger.js';
@@ -11,9 +11,10 @@ import { getTranslate } from './rules/useTranslate.js';
 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];
 export const svelteMergers = pipeMachines([
-    ...DEFAULT_MERGERERS,
+    ...DEFAULT_MERGERS,
     tFunctionMerger,
     getTranslateMerger,
     tComponentMerger,
@@ -23,7 +24,7 @@ export const ParserSvelte = () => {
     return Parser({
         mappers: svelteMappers,
         blocks: Object.assign({}, DEFAULT_BLOCKS),
-        rules: [tFunction, getTranslate, tComponent, scriptTag],
+        rules: [globalTFunction, tFunction, getTranslate, tComponent, scriptTag],
         treeTransform: svelteTreeTransform,
         merger: svelteMergers,
     });

package/dist/extractor/parserVue/ParserVue.js

@@ -1,26 +1,26 @@
 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 { 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];
 export const vueMergers = pipeMachines([
-    ...DEFAULT_MERGERERS,
+    ...DEFAULT_MERGERS,
     hyphenPropsMerger,
-    globalTFunctionMerger,
+    customTCallMerger(['$t', 'this.$t']),
     tFunctionMerger,
     useTranslateMerger,
     tComponentMerger,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolgee/cli",
-  "version": "2.10.1",
+  "version": "2.11.0",
   "type": "module",
   "description": "A tool to interact with the Tolgee Platform through CLI",
   "repository": {

package/dist/extractor/parserVue/tokenMergers/globalTFunctionMerger.js

@@ -1,36 +0,0 @@
-// $t(
-export const globalTFunctionMerger = {
-    initial: 0 /* S.Idle */,
-    step: (state, t, end) => {
-        const type = t.customType;
-        const token = t.token;
-        switch (state) {
-            case 0 /* S.Idle */:
-                if (type === 'function.call' && token === '$t') {
-                    return 1 /* S.ExpectBracket */;
-                }
-                else if (type === 'variable' && token === 'this') {
-                    return 2 /* S.ExpectDot */;
-                }
-                else if (type === 'acessor.dot') {
-                    return 4 /* S.Ignore */;
-                }
-                break;
-            case 2 /* S.ExpectDot */:
-                if (type === 'acessor.dot') {
-                    return 3 /* S.ExpectCall */;
-                }
-                break;
-            case 3 /* S.ExpectCall */:
-                if (type === 'function.call' && token === '$t') {
-                    return 1 /* S.ExpectBracket */;
-                }
-                break;
-            case 1 /* S.ExpectBracket */:
-                if (type === 'expression.begin') {
-                    return end.MERGE_ALL;
-                }
-        }
-    },
-    customType: 'trigger.global.t.function',
-};