@tolgee/cli 1.1.2 → 1.3.0

package/dist/commands/login.js

@@ -10,7 +10,7 @@ async function loginHandler(key) {
         keyInfo = await RestClient.getApiKeyInformation(opts.apiUrl, key);
     }
     catch (e) {
-        if (e instanceof HttpError && e.response.status === 403) {
+        if (e instanceof HttpError && e.response.status === 401) {
             error("Couldn't log in: the API key you provided is invalid.");
             process.exit(1);
         }

package/dist/commands/pull.js

@@ -1,21 +1,33 @@
 import { Command, Option } from 'commander';
 import { unzipBuffer } from '../utils/zip.js';
 import { overwriteDir } from '../utils/overwriteDir.js';
-import { loading, success } from '../utils/logger.js';
+import { error, loading, success } from '../utils/logger.js';
+import { HttpError } from '../client/errors.js';
 async function fetchZipBlob(opts) {
     return opts.client.export.export({
         format: opts.format,
         languages: opts.languages,
         filterState: opts.states,
         structureDelimiter: opts.delimiter,
+        filterNamespace: opts.namespaces,
     });
 }
 async function pullHandler(path) {
     const opts = this.optsWithGlobals();
     await overwriteDir(path, opts.overwrite);
-    const zipBlob = await loading('Fetching strings from Tolgee...', fetchZipBlob(opts));
-    await loading('Extracting strings...', unzipBuffer(zipBlob, path));
-    success('Done!');
+    try {
+        const zipBlob = await loading('Fetching strings from Tolgee...', fetchZipBlob(opts));
+        await loading('Extracting strings...', unzipBuffer(zipBlob, path));
+        success('Done!');
+    }
+    catch (e) {
+        if (e instanceof HttpError && e.response.status === 400) {
+            const res = await e.response.json();
+            error(`Please check if your parameters, including namespaces, are configured correctly. Tolgee responded with: ${res.code}`);
+            return;
+        }
+        throw e;
+    }
 }
 export default new Command()
     .name('pull')
@@ -32,5 +44,6 @@ export default new Command()
     .addOption(new Option('-d, --delimiter', 'Structure delimiter to use. By default, Tolgee interprets `.` as a nested structure. You can change the delimiter, or disable structure formatting by not specifying any value to the option')
     .default('.')
     .argParser((v) => v || ''))
+    .addOption(new Option('-n, --namespaces <namespaces...>', 'List of namespaces to pull. Defaults to all namespaces'))
     .option('-o, --overwrite', 'Whether to automatically overwrite existing files. BE CAREFUL, THIS WILL WIPE *ALL* THE CONTENTS OF THE TARGET FOLDER. If unspecified, the user will be prompted interactively, or the command will fail when in non-interactive')
     .action(pullHandler);

package/dist/config/tolgeerc.js

@@ -49,7 +49,7 @@ function parseConfig(rc) {
         if (typeof rc.delimiter !== 'string' && rc.delimiter !== null) {
             throw new Error('Invalid config: delimiter is not a string');
         }
-        cfg.delimiter = rc.delimiter || void 0;
+        cfg.delimiter = rc.delimiter || '';
     }
     return cfg;
 }

package/dist/constants.js

@@ -8,4 +8,4 @@ export const USER_AGENT = `Tolgee-CLI/${VERSION} (+https://github.com/tolgee/tol
 export const DEFAULT_API_URL = new URL('https://app.tolgee.io');
 export const API_KEY_PAT_PREFIX = 'tgpat_';
 export const API_KEY_PAK_PREFIX = 'tgpak_';
-export const SDKS = ['react'];
+export const SDKS = ['react', 'vue', 'svelte'];

package/dist/extractor/extractor.js

@@ -1,8 +1,10 @@
 import { extname } from 'path';
 import { interpret } from 'xstate';
 import reactExtractorMachine from './machines/react.js';
+import vueExtractorMachine from './machines/vue/extract.js';
 import svelteExtractorMachine from './machines/svelte.js';
 import commentsExtractorMachine from './machines/comments.js';
+import vueSfcProcessor from './processors/vueSfc.js';
 import tokenizer from './tokenizer.js';
 const REACT_EXTS = [
     '.js',
@@ -14,6 +16,7 @@ const REACT_EXTS = [
     '.jsx',
     '.tsx',
 ];
+const VUE_EXTS = REACT_EXTS;
 const ALL_EXTS = [
     '.js',
     '.mjs',
@@ -25,11 +28,13 @@ const ALL_EXTS = [
     '.tsx',
     '.svelte',
 ];
-function pickMachine(code, fileName) {
-    const ext = extname(fileName);
+function pickMachine(code, ext) {
     if (REACT_EXTS.includes(ext) && code.includes('@tolgee/react')) {
         return reactExtractorMachine;
     }
+    if (VUE_EXTS.includes(ext) && code.includes('@tolgee/vue')) {
+        return vueExtractorMachine;
+    }
     if (ext === '.svelte' && code.includes('@tolgee/svelte')) {
         return svelteExtractorMachine;
     }
@@ -40,7 +45,15 @@ function pickMachine(code, fileName) {
     return null;
 }
 export default async function extractor(code, fileName) {
-    const machineSpec = pickMachine(code, fileName);
+    const ext = extname(fileName);
+    if (ext === '.vue' &&
+        (code.includes('$t') ||
+            code.includes('@tolgee/vue') ||
+            code.includes('@tolgee-key') ||
+            code.includes('@tolgee-ignore'))) {
+        return vueSfcProcessor(code, fileName);
+    }
+    const machineSpec = pickMachine(code, ext);
     if (!machineSpec) {
         return { warnings: [], keys: [] };
     }

package/dist/extractor/machines/react.js

@@ -1,4 +1,5 @@
 import { createMachine, assign, send, forwardTo } from 'xstate';
+import translateCallMachine from './shared/translateCall.js';
 import propertiesMachine from './shared/properties.js';
 import commentsService from './shared/comments.js';
 const VOID_KEY = { keyName: '', line: -1 };
@@ -456,111 +457,38 @@ export default createMachine({
                     },
                 },
                 call: {
-                    on: {
-                        'punctuation.definition.string.begin.ts': 'param_string',
-                        'punctuation.definition.string.template.begin.ts': 'param_string',
-                        'variable.other.readwrite.ts': [
-                            {
-                                target: 'idle',
-                                actions: 'dynamicOptions',
-                                cond: (ctx) => !!ctx.key.keyName,
-                            },
+                    invoke: {
+                        id: 'tCall',
+                        src: translateCallMachine,
+                        onDone: [
                             {
                                 target: 'idle',
                                 actions: 'dynamicKeyName',
-                            },
-                        ],
-                        'punctuation.definition.block.ts': {
-                            target: 'param_object',
-                            cond: (_ctx, evt) => evt.token === '{',
-                        },
-                        'meta.brace.round.ts': {
-                            target: 'idle',
-                            cond: (_ctx, evt) => evt.token === ')',
-                            actions: 'pushKey',
-                        },
-                    },
-                },
-                param_string: {
-                    on: {
-                        '*': [
-                            {
-                                target: 'param_end',
-                                actions: ['storeKeyName', 'storeKeyCurrentNamespace'],
-                                cond: (ctx) => !ctx.key.keyName,
-                            },
-                            {
-                                target: 'param_end',
-                                actions: ['storeKeyDefault', 'storeKeyCurrentNamespace'],
-                                cond: (ctx) => !!ctx.key.keyName,
-                            },
-                        ],
-                    },
-                },
-                param_end: {
-                    on: {
-                        'punctuation.separator.comma.ts': 'call',
-                        'punctuation.definition.template-expression.begin.ts': [
-                            {
-                                target: 'param_end_warn',
-                                actions: 'dynamicKeyDefault',
-                                cond: (ctx) => !!ctx.key.defaultValue,
+                                cond: (_, evt) => evt.data.keyName === false,
                             },
                             {
                                 target: 'idle',
-                                actions: 'dynamicKeyName',
-                            },
-                        ],
-                        'keyword.operator.arithmetic.ts': [
-                            {
-                                target: 'param_end_warn',
-                                actions: 'dynamicKeyDefault',
-                                cond: (ctx) => !!ctx.key.defaultValue,
+                                actions: 'dynamicNamespace',
+                                cond: (_, evt) => evt.data.namespace === false,
                             },
                             {
                                 target: 'idle',
-                                actions: 'dynamicKeyName',
+                                actions: 'dynamicOptions',
+                                cond: (_, evt) => evt.data.dynamicOptions,
                             },
-                        ],
-                        'meta.brace.round.ts': {
-                            target: 'idle',
-                            cond: (_ctx, evt) => evt.token === ')',
-                            actions: 'pushKey',
-                        },
-                    },
-                },
-                param_end_warn: {
-                    on: {
-                        'punctuation.separator.comma.ts': 'call',
-                        'meta.brace.round.ts': {
-                            target: 'idle',
-                            cond: (_ctx, evt) => evt.token === ')',
-                            actions: 'pushKey',
-                        },
-                    },
-                },
-                param_object: {
-                    invoke: {
-                        id: 'propertiesMachine',
-                        src: propertiesMachine,
-                        data: {
-                            depth: 1,
-                        },
-                        onDone: [
                             {
                                 target: 'idle',
-                                actions: 'emitWarningFromParameters',
-                                cond: 'isPropertiesDataDynamic',
+                                cond: (_, evt) => !evt.data.keyName,
                             },
                             {
                                 target: 'idle',
-                                actions: ['consumeParameters', 'pushKey'],
+                                actions: 'consumeTranslateCall',
                             },
                         ],
                     },
                     on: {
                         '*': {
-                            actions: forwardTo('propertiesMachine'),
+                            actions: forwardTo('tCall'),
                         },
                     },
                 },
@@ -613,6 +541,43 @@ export default createMachine({
                 { warning: 'W_DYNAMIC_NAMESPACE', line: ctx.line },
             ],
         }),
+        consumeTranslateCall: assign({
+            warnings: (ctx, evt) => {
+                const utNamespace = ctx.hooks.length
+                    ? ctx.hooks[ctx.hooks.length - 1].namespace
+                    : undefined;
+                if (!evt.data.namespace && utNamespace === false) {
+                    return [
+                        ...ctx.warnings,
+                        { warning: 'W_UNRESOLVABLE_NAMESPACE', line: ctx.line },
+                    ];
+                }
+                if (evt.data.defaultValue === false) {
+                    return [
+                        ...ctx.warnings,
+                        { warning: 'W_DYNAMIC_DEFAULT_VALUE', line: ctx.line },
+                    ];
+                }
+                return ctx.warnings;
+            },
+            keys: (ctx, evt) => {
+                const utNamespace = ctx.hooks.length
+                    ? ctx.hooks[ctx.hooks.length - 1].namespace
+                    : undefined;
+                const ns = evt.data.namespace === null ? utNamespace : evt.data.namespace;
+                if (!evt.data.keyName || ns === false)
+                    return ctx.keys;
+                return [
+                    ...ctx.keys,
+                    {
+                        keyName: evt.data.keyName,
+                        namespace: ns || undefined,
+                        defaultValue: evt.data.defaultValue || undefined,
+                        line: ctx.line,
+                    },
+                ];
+            },
+        }),
         consumeParameters: assign({
             key: (ctx, evt) => ({
                 // We don't want the key and default value to be overridable
@@ -643,7 +608,7 @@ export default createMachine({
                     line: ctx.line,
                 },
             ],
-            key: (_ctx, _evt) => VOID_KEY,
+            key: VOID_KEY,
         }),
         appendChildren: assign({
             children: (ctx, evt) => (ctx.children ?? '') + evt.token,
@@ -662,20 +627,19 @@ export default createMachine({
         storeKeyDefault: assign({
             key: (ctx, evt) => ({ ...ctx.key, defaultValue: evt.token }),
         }),
-        storeKeyCurrentNamespace: assign({
-            key: (ctx, _evt) => ({
-                ...ctx.key,
-                namespace: ctx.hooks.length
-                    ? ctx.hooks[ctx.hooks.length - 1].namespace
-                    : undefined,
-            }),
-        }),
         dynamicKeyName: assign({
             warnings: (ctx, _evt) => [
                 ...ctx.warnings,
                 { warning: 'W_DYNAMIC_KEY', line: ctx.line },
             ],
-            key: (_ctx, _evt) => VOID_KEY,
+            key: VOID_KEY,
+        }),
+        dynamicNamespace: assign({
+            warnings: (ctx, _evt) => [
+                ...ctx.warnings,
+                { warning: 'W_DYNAMIC_NAMESPACE', line: ctx.line },
+            ],
+            key: VOID_KEY,
         }),
         dynamicKeyDefault: assign({
             key: (ctx, _evt) => ({ ...ctx.key, defaultValue: undefined }),
@@ -685,7 +649,7 @@ export default createMachine({
             ],
         }),
         dynamicOptions: assign({
-            key: (ctx, _evt) => VOID_KEY,
+            key: VOID_KEY,
             warnings: (ctx, _evt) => [
                 ...ctx.warnings,
                 { warning: 'W_DYNAMIC_OPTIONS', line: ctx.line },
@@ -704,14 +668,6 @@ export default createMachine({
             ],
         }),
         pushKey: assign({
-            warnings: (ctx, _evt) => {
-                if (!ctx.key.keyName || ctx.key.namespace !== false)
-                    return ctx.warnings;
-                return [
-                    ...ctx.warnings,
-                    { warning: 'W_UNRESOLVABLE_NAMESPACE', line: ctx.line },
-                ];
-            },
             keys: (ctx, _evt) => {
                 if (!ctx.key.keyName || ctx.key.namespace === false)
                     return ctx.keys;

package/dist/extractor/machines/shared/properties.js

@@ -8,6 +8,7 @@ export default createMachine({
         property: null,
         depth: 0,
         static: false,
+        nextDynamic: false,
         keyName: null,
         defaultValue: null,
         namespace: null,
@@ -47,6 +48,37 @@ export default createMachine({
                 'punctuation.separator.key-value.svelte': {
                     target: 'value',
                 },
+                // Vue
+                'punctuation.attribute-shorthand.event.html.vue': [
+                    {
+                        cond: (_, evt) => evt.token === '@',
+                        actions: ['markPropertyAsDynamic', 'markNextPropertyAsDynamic'],
+                    },
+                ],
+                'entity.other.attribute-name.html.vue': [
+                    {
+                        cond: (ctx) => ctx.nextDynamic,
+                        actions: 'markImmediatePropertyAsDynamic',
+                    },
+                    {
+                        actions: [
+                            'markPropertyAsDynamic',
+                            'unmarkAsStatic',
+                            'storePropertyType',
+                        ],
+                    },
+                ],
+                'punctuation.separator.key-value.html.vue': {
+                    target: 'value',
+                },
+                'entity.other.attribute-name.html': [
+                    {
+                        actions: ['markPropertyAsDynamic', 'storePropertyType'],
+                    },
+                ],
+                'punctuation.separator.key-value.html': {
+                    target: 'value',
+                },
             },
         },
         complex_key: {
@@ -76,6 +108,7 @@ export default createMachine({
                 'punctuation.definition.string.template.begin.ts': 'value_string',
                 'punctuation.definition.string.begin.svelte': 'value_string',
                 'punctuation.definition.string.template.begin.svelte': 'value_string',
+                'punctuation.definition.string.begin.html': 'value_string',
                 // Variable
                 'variable.other.readwrite.ts': {
                     target: 'idle',
@@ -98,6 +131,15 @@ export default createMachine({
                         'unmarkAsStatic',
                     ],
                 },
+                // Vue
+                'string.unquoted.html': {
+                    target: 'idle',
+                    actions: [
+                        'storePropertyValue',
+                        'clearPropertyType',
+                        'unmarkAsStatic',
+                    ],
+                },
                 // Value end
                 'punctuation.separator.comma.ts': {
                     target: 'idle',
@@ -137,6 +179,10 @@ export default createMachine({
                     target: 'idle',
                     actions: ['storeEmptyPropertyValue', 'clearPropertyType'],
                 },
+                'punctuation.definition.string.end.html': {
+                    target: 'idle',
+                    actions: ['storeEmptyPropertyValue', 'clearPropertyType'],
+                },
                 '*': [
                     {
                         target: 'idle',
@@ -186,6 +232,15 @@ export default createMachine({
                     target: 'idle',
                     actions: 'clearPropertyType',
                 },
+                // Vue
+                'punctuation.definition.string.end.html.vue': {
+                    target: 'idle',
+                    actions: 'clearPropertyType',
+                },
+                'punctuation.definition.string.end.html': {
+                    target: 'idle',
+                    actions: 'clearPropertyType',
+                },
             },
         },
         end: {
@@ -221,15 +276,27 @@ export default createMachine({
             target: 'end',
             actions: 'markPropertyAsDynamic',
         },
+        'punctuation.definition.tag.end.html.vue': {
+            target: 'end',
+            actions: 'markPropertyAsDynamic',
+        },
+        'punctuation.definition.tag.end.html': {
+            target: 'end',
+            actions: 'markPropertyAsDynamic',
+        },
     },
 }, {
     guards: {
         isOpenCurly: (_ctx, evt) => evt.token === '{' &&
             !evt.scopes.includes('meta.embedded.expression.tsx') &&
-            !evt.scopes.includes('meta.embedded.expression.svelte'),
+            !evt.scopes.includes('meta.embedded.expression.svelte') &&
+            (!evt.scopes.includes('source.ts.embedded.html.vue') ||
+                evt.scopes.includes('expression.embedded.vue')),
         isCloseCurly: (_ctx, evt) => evt.token === '}' &&
             !evt.scopes.includes('meta.embedded.expression.tsx') &&
-            !evt.scopes.includes('meta.embedded.expression.svelte'),
+            !evt.scopes.includes('meta.embedded.expression.svelte') &&
+            (!evt.scopes.includes('source.ts.embedded.html.vue') ||
+                evt.scopes.includes('expression.embedded.vue')),
         isFinalCloseCurly: (ctx, evt) => evt.token === '}' && ctx.depth === 1,
         isOpenSquare: (_ctx, evt) => evt.token === '[',
         isCloseSquare: (_ctx, evt) => evt.token === ']',
@@ -256,7 +323,11 @@ export default createMachine({
             defaultValue: (ctx) => ctx.property === 'defaultValue' ? '' : ctx.defaultValue,
             namespace: (ctx) => (ctx.property === 'ns' ? '' : ctx.namespace),
         }),
+        markNextPropertyAsDynamic: assign({
+            nextDynamic: true,
+        }),
         markPropertyAsDynamic: assign({
+            nextDynamic: false,
             keyName: (ctx, _evt) => ctx.property === 'key' || ctx.property === 'keyName'
                 ? false
                 : ctx.keyName,
@@ -264,6 +335,7 @@ export default createMachine({
             namespace: (ctx, _evt) => ctx.property === 'ns' ? false : ctx.namespace,
         }),
         markImmediatePropertyAsDynamic: assign({
+            nextDynamic: false,
             keyName: (ctx, evt) => evt.token === 'key' || evt.token === 'keyName' ? false : ctx.keyName,
             defaultValue: (ctx, evt) => evt.token === 'defaultValue' ? false : ctx.defaultValue,
             namespace: (ctx, evt) => (evt.token === 'ns' ? false : ctx.namespace),
@@ -275,10 +347,10 @@ export default createMachine({
             depth: (ctx, _evt) => ctx.depth - 1,
         }),
         markAsStatic: assign({
-            static: (_ctx, _evt) => true,
+            static: true,
         }),
         unmarkAsStatic: assign({
-            static: (_ctx, _evt) => false,
+            static: false,
         }),
     },
 });

package/dist/extractor/machines/shared/translateCall.js

@@ -0,0 +1,141 @@
+// This machine is responsible for extracting data from
+// calls to `t`. It is shared across multiple machines since
+// all t functions share the same signature.
+import { createMachine, assign, forwardTo } from 'xstate';
+import propertiesMachine from './properties.js';
+export default createMachine({
+    predictableActionArguments: true,
+    id: 'tCall',
+    initial: 'idle',
+    context: {
+        keyName: null,
+        defaultValue: null,
+        namespace: null,
+        dynamicOptions: false,
+    },
+    states: {
+        idle: {
+            on: {
+                'punctuation.definition.string.begin.ts': 'string',
+                'punctuation.definition.string.template.begin.ts': 'string',
+                'variable.other.readwrite.ts': [
+                    {
+                        target: 'done',
+                        actions: 'dynamicOptions',
+                        cond: (ctx) => !!ctx.keyName,
+                    },
+                    {
+                        target: 'done',
+                        actions: 'dynamicKeyName',
+                    },
+                ],
+                'punctuation.definition.block.ts': {
+                    target: 'object',
+                    cond: (_ctx, evt) => evt.token === '{',
+                },
+                'meta.brace.round.ts': {
+                    target: 'done',
+                    cond: (_ctx, evt) => evt.token === ')',
+                },
+            },
+        },
+        string: {
+            on: {
+                '*': [
+                    {
+                        target: 'string_end',
+                        actions: 'storeKeyName',
+                        cond: (ctx) => !ctx.keyName,
+                    },
+                    {
+                        target: 'string_end',
+                        actions: 'storeDefaultValue',
+                        cond: (ctx) => !!ctx.keyName,
+                    },
+                ],
+            },
+        },
+        string_end: {
+            on: {
+                'punctuation.separator.comma.ts': 'idle',
+                'punctuation.definition.template-expression.begin.ts': [
+                    {
+                        target: 'string_end_warn',
+                        actions: 'dynamicDefaultValue',
+                        cond: (ctx) => !!ctx.defaultValue,
+                    },
+                    {
+                        target: 'done',
+                        actions: 'dynamicKeyName',
+                    },
+                ],
+                'keyword.operator.arithmetic.ts': [
+                    {
+                        target: 'string_end_warn',
+                        actions: 'dynamicDefaultValue',
+                        cond: (ctx) => !!ctx.defaultValue,
+                    },
+                    {
+                        target: 'done',
+                        actions: 'dynamicKeyName',
+                    },
+                ],
+                'meta.brace.round.ts': {
+                    target: 'done',
+                    cond: (_ctx, evt) => evt.token === ')',
+                },
+            },
+        },
+        string_end_warn: {
+            on: {
+                'punctuation.separator.comma.ts': 'idle',
+                'meta.brace.round.ts': {
+                    target: 'done',
+                    cond: (_ctx, evt) => evt.token === ')',
+                },
+            },
+        },
+        object: {
+            invoke: {
+                id: 'propertiesMachine',
+                src: propertiesMachine,
+                data: {
+                    depth: 1,
+                },
+                onDone: {
+                    target: 'done',
+                    actions: 'consumeParameters',
+                },
+            },
+            on: {
+                '*': {
+                    actions: forwardTo('propertiesMachine'),
+                },
+            },
+        },
+        done: { type: 'final', data: (ctx) => ctx },
+    },
+}, {
+    actions: {
+        storeKeyName: assign({
+            keyName: (_, evt) => evt.token,
+        }),
+        storeDefaultValue: assign({
+            defaultValue: (_, evt) => evt.token,
+        }),
+        consumeParameters: assign({
+            keyName: (ctx, evt) => ctx.keyName === null ? evt.data.keyName : ctx.keyName,
+            namespace: (ctx, evt) => ctx.namespace === null ? evt.data.namespace : ctx.namespace,
+            defaultValue: (ctx, evt) => ctx.defaultValue === null ? evt.data.defaultValue : ctx.defaultValue,
+        }),
+        dynamicKeyName: assign({
+            keyName: () => false,
+        }),
+        dynamicDefaultValue: assign({
+            defaultValue: () => false,
+        }),
+        dynamicOptions: assign({
+            dynamicOptions: () => true,
+        }),
+    },
+});