@tolgee/cli 1.1.2 → 1.3.0

package/dist/extractor/machines/svelte.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 };
@@ -237,111 +238,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'),
                         },
                     },
                 },
@@ -381,6 +309,37 @@ export default createMachine({
                 { warning: 'W_DYNAMIC_NAMESPACE', line: ctx.line },
             ],
         }),
+        consumeTranslateCall: assign({
+            warnings: (ctx, evt) => {
+                if (!evt.data.namespace && ctx.getTranslate === 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 ns = evt.data.namespace === null ? ctx.getTranslate : 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) => ({
                 keyName: ctx.key.keyName || evt.data.keyName,
@@ -407,50 +366,30 @@ export default createMachine({
                     line: ctx.line,
                 },
             ],
-            key: (_ctx, _evt) => VOID_KEY,
-        }),
-        storeKeyName: assign({
-            key: (ctx, evt) => ({ ...ctx.key, keyName: evt.token }),
-        }),
-        storeKeyDefault: assign({
-            key: (ctx, evt) => ({ ...ctx.key, defaultValue: evt.token }),
-        }),
-        storeKeyCurrentNamespace: assign({
-            key: (ctx, _evt) => ({
-                ...ctx.key,
-                namespace: ctx.getTranslate !== null ? ctx.getTranslate : undefined,
-            }),
+            key: VOID_KEY,
         }),
         dynamicKeyName: assign({
             warnings: (ctx, _evt) => [
                 ...ctx.warnings,
                 { warning: 'W_DYNAMIC_KEY', line: ctx.line },
             ],
-            key: (_ctx, _evt) => VOID_KEY,
+            key: VOID_KEY,
         }),
-        dynamicKeyDefault: assign({
-            key: (ctx, _evt) => ({ ...ctx.key, defaultValue: undefined }),
+        dynamicNamespace: assign({
             warnings: (ctx, _evt) => [
                 ...ctx.warnings,
-                { warning: 'W_DYNAMIC_DEFAULT_VALUE', line: ctx.line },
+                { warning: 'W_DYNAMIC_NAMESPACE', line: ctx.line },
             ],
+            key: VOID_KEY,
         }),
         dynamicOptions: assign({
-            key: (_ctx, _evt) => VOID_KEY,
+            key: VOID_KEY,
             warnings: (ctx, _evt) => [
                 ...ctx.warnings,
                 { warning: 'W_DYNAMIC_OPTIONS', line: ctx.line },
             ],
         }),
         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/vue/decoder.js

@@ -0,0 +1,194 @@
+// This machine is responsible for decoding a Vue SFC file.
+// It extracts the tokens in 3 different categories:
+//  - The setup function tokens
+//  - The scripts (excluding setup)
+//  - The template
+//
+// Property of the machine: will always include an
+// extra token for all categories. Consumers must be
+// aware of this!
+import { createMachine, assign } from 'xstate';
+// This state machine is responsible for extracting translation key properties from an object/props
+export default createMachine({
+    predictableActionArguments: true,
+    id: 'properties',
+    initial: 'idle',
+    context: {
+        setup: [],
+        script: [],
+        template: [],
+        scriptSetupConsumed: false,
+        invalidSetup: null,
+        depth: 0,
+        memoizedDepth: 0,
+    },
+    states: {
+        idle: {
+            on: {
+                'punctuation.definition.tag.begin.html.vue': 'beginTag',
+            },
+        },
+        beginTag: {
+            on: {
+                'entity.name.tag.script.html.vue': 'scriptTag',
+                'entity.name.tag.template.html.vue': {
+                    cond: (_, evt) => evt.token === 'template',
+                    actions: 'incrementDepth',
+                    target: 'templateTag',
+                },
+                '*': 'idle',
+            },
+        },
+        scriptTag: {
+            on: {
+                'entity.other.attribute-name.html': [
+                    {
+                        cond: (_, evt) => evt.token === 'setup',
+                        actions: ['consumeSetupScript'],
+                        target: 'scriptSetupTag',
+                    },
+                ],
+                'punctuation.definition.tag.end.html.vue': 'script',
+            },
+        },
+        scriptSetupTag: {
+            on: {
+                'punctuation.definition.tag.end.html.vue': 'setup',
+            },
+        },
+        templateTag: {
+            on: {
+                'punctuation.definition.tag.end.html.vue': 'template',
+            },
+        },
+        setup: {
+            on: {
+                '*': { actions: ['consumeSetupToken'] },
+                'entity.name.tag.script.html.vue': 'idle',
+            },
+        },
+        script: {
+            on: {
+                '*': { actions: ['consumeScriptToken'] },
+                'meta.export.default.ts': {
+                    actions: ['resetDepth'],
+                    target: 'scriptExport',
+                },
+                'entity.name.tag.script.html.vue': 'idle',
+            },
+        },
+        scriptExport: {
+            on: {
+                '*': { actions: ['consumeScriptToken'] },
+                'punctuation.definition.block.ts': [
+                    {
+                        cond: (_, evt) => evt.token === '{',
+                        actions: ['incrementDepth'],
+                    },
+                    {
+                        cond: (_, evt) => evt.token === '}',
+                        actions: ['decrementDepth'],
+                    },
+                ],
+                'entity.name.function.ts': {
+                    cond: (_, evt) => evt.token === 'setup',
+                    actions: ['storeDepth'],
+                    target: 'scriptSetup',
+                },
+                'meta.object-literal.key.ts': {
+                    cond: (_, evt) => evt.token === 'setup',
+                    actions: ['markBadSetupUse'],
+                },
+                'entity.name.tag.script.html.vue': 'idle',
+            },
+        },
+        scriptSetup: {
+            on: {
+                '*': {
+                    cond: (ctx) => !ctx.scriptSetupConsumed,
+                    actions: ['consumeSetupToken'],
+                },
+                'punctuation.definition.block.ts': [
+                    {
+                        cond: (_, evt) => evt.token === '{',
+                        actions: ['consumeSetupToken', 'incrementDepth'],
+                    },
+                    {
+                        cond: (ctx, evt) => evt.token === '}' && ctx.depth - 1 === ctx.memoizedDepth,
+                        actions: ['consumeSetupToken', 'decrementDepth'],
+                        target: 'scriptExport',
+                    },
+                    {
+                        cond: (_, evt) => evt.token === '}',
+                        actions: ['consumeSetupToken', 'decrementDepth'],
+                    },
+                ],
+            },
+        },
+        template: {
+            on: {
+                '*': { actions: ['consumeTemplateToken'] },
+                'punctuation.definition.tag.begin.html.vue': {
+                    cond: (_, evt) => evt.token === '<',
+                    target: 'nestedTemplateTag',
+                },
+                'entity.name.tag.template.html.vue': [
+                    {
+                        cond: (ctx, evt) => evt.token === 'template' && ctx.depth === 1,
+                        actions: 'decrementDepth',
+                        target: 'idle',
+                    },
+                    {
+                        cond: (_, evt) => evt.token === 'template',
+                        actions: 'decrementDepth',
+                    },
+                ],
+            },
+        },
+        nestedTemplateTag: {
+            on: {
+                'entity.name.tag.template.html.vue': [
+                    {
+                        cond: (_, evt) => evt.token === 'template',
+                        actions: 'incrementDepth',
+                        target: 'template',
+                    },
+                    {
+                        target: 'template',
+                    },
+                ],
+            },
+        },
+    },
+}, {
+    actions: {
+        consumeSetupScript: assign({
+            setup: () => [],
+            scriptSetupConsumed: () => true,
+        }),
+        consumeSetupToken: assign({
+            setup: (ctx, evt) => [...ctx.setup, evt],
+        }),
+        consumeScriptToken: assign({
+            script: (ctx, evt) => [...ctx.script, evt],
+        }),
+        consumeTemplateToken: assign({
+            template: (ctx, evt) => [...ctx.template, evt],
+        }),
+        resetDepth: assign({
+            depth: () => 0,
+        }),
+        incrementDepth: assign({
+            depth: (ctx) => ctx.depth + 1,
+        }),
+        decrementDepth: assign({
+            depth: (ctx) => ctx.depth - 1,
+        }),
+        storeDepth: assign({
+            memoizedDepth: (ctx) => ctx.depth,
+        }),
+        markBadSetupUse: assign({
+            invalidSetup: (_, evt) => evt.line,
+        }),
+    },
+});