@tolgee/cli 1.0.1 → 1.1.0

package/dist/extractor/machines/svelte.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const xstate_1 = require("xstate");
+const properties_1 = __importDefault(require("./shared/properties"));
+const comments_1 = __importDefault(require("./shared/comments"));
+const VOID_KEY = { keyName: '', line: -1 };
+exports.default = (0, xstate_1.createMachine)({
+    predictableActionArguments: true,
+    id: 'svelteExtractor',
+    type: 'parallel',
+    context: {
+        children: '',
+        line: 0,
+        key: VOID_KEY,
+        useTranslate: null,
+        ignore: null,
+        keys: [],
+        warnings: [],
+    },
+    states: {
+        comments: {
+            invoke: {
+                id: 'comments',
+                src: () => comments_1.default,
+            },
+            on: {
+                // Service messages
+                MAGIC_COMMENT: [
+                    {
+                        actions: 'ignoreNextLine',
+                        cond: (_ctx, evt) => evt.kind === 'ignore',
+                    },
+                    {
+                        actions: 'pushImmediateKey',
+                        cond: (_ctx, evt) => evt.kind === 'key',
+                    },
+                ],
+                WARNING: {
+                    actions: 'pushWarning',
+                },
+                // Code messages
+                'comment.line.double-slash.ts': {
+                    actions: (0, xstate_1.send)((_ctx, evt) => ({
+                        type: 'COMMENT',
+                        data: evt.token,
+                        line: evt.line,
+                    }), { to: 'comments' }),
+                },
+                'comment.block.ts': {
+                    actions: (0, xstate_1.send)((_ctx, evt) => ({
+                        type: 'COMMENT',
+                        data: evt.token,
+                        line: evt.line,
+                    }), { to: 'comments' }),
+                },
+                'comment.block.svelte': {
+                    actions: (0, xstate_1.send)((_ctx, evt) => ({
+                        type: 'COMMENT',
+                        data: evt.token,
+                        line: evt.line,
+                    }), { to: 'comments' }),
+                },
+                newline: {
+                    actions: 'warnUnusedIgnore',
+                    cond: (ctx, evt) => ctx.ignore?.type === 'ignore' && ctx.ignore.line === evt.line,
+                },
+            },
+        },
+        useTranslate: {
+            initial: 'idle',
+            states: {
+                idle: {
+                    on: {
+                        'entity.name.function.ts': {
+                            target: 'func',
+                            actions: 'storeLine',
+                            cond: (_ctx, evt) => evt.token === 'useTranslate',
+                        },
+                    },
+                },
+                func: {
+                    on: {
+                        '*': 'idle',
+                        newline: undefined,
+                        'meta.block.ts': undefined,
+                        'meta.var.expr.ts': undefined,
+                        'meta.brace.round.ts': [
+                            {
+                                target: 'idle',
+                                actions: 'consumeIgnoredLine',
+                                cond: (ctx, evt) => ctx.ignore?.line === ctx.line &&
+                                    ctx.ignore.type === 'ignore' &&
+                                    evt.token === '(',
+                            },
+                            {
+                                target: 'call',
+                                cond: (_ctx, evt) => evt.token === '(',
+                            },
+                        ],
+                    },
+                },
+                call: {
+                    on: {
+                        'punctuation.definition.string.begin.ts': 'namespace',
+                        'punctuation.definition.string.template.begin.ts': 'namespace',
+                        'variable.other.readwrite.ts': {
+                            target: 'idle',
+                            actions: ['storeUseTranslate', 'markUseTranslateAsDynamic'],
+                        },
+                        'meta.brace.round.ts': {
+                            target: 'idle',
+                            cond: (_ctx, evt) => evt.token === ')',
+                            actions: 'storeUseTranslate',
+                        },
+                    },
+                },
+                namespace: {
+                    on: {
+                        '*': {
+                            target: 'namespace_end',
+                            actions: 'storeNamespacedUseTranslate',
+                        },
+                    },
+                },
+                namespace_end: {
+                    on: {
+                        'punctuation.separator.comma.ts': 'idle',
+                        'meta.brace.round.ts': 'idle',
+                        'punctuation.definition.template-expression.begin.ts': {
+                            target: 'idle',
+                            actions: 'markUseTranslateAsDynamic',
+                        },
+                        'keyword.operator.arithmetic.ts': {
+                            target: 'idle',
+                            actions: 'markUseTranslateAsDynamic',
+                        },
+                    },
+                },
+            },
+        },
+        component: {
+            initial: 'idle',
+            states: {
+                idle: {
+                    on: {
+                        'punctuation.definition.tag.begin.svelte': {
+                            target: 'tag',
+                            actions: 'storeLine',
+                            cond: (_ctx, evt) => evt.token === '<',
+                        },
+                    },
+                },
+                tag: {
+                    on: {
+                        '*': 'idle',
+                        newline: undefined,
+                        'meta.tag.start.svelte': undefined,
+                        'support.class.component.svelte': [
+                            {
+                                target: 'idle',
+                                actions: 'consumeIgnoredLine',
+                                cond: (ctx, evt) => ctx.ignore?.line === ctx.line && evt.token === 'T',
+                            },
+                            {
+                                target: 'props',
+                                cond: (_ctx, evt) => evt.token === 'T',
+                            },
+                        ],
+                    },
+                },
+                props: {
+                    invoke: {
+                        id: 'propertiesMachine',
+                        src: properties_1.default,
+                        onDone: [
+                            {
+                                target: 'idle',
+                                actions: 'emitWarningFromParameters',
+                                cond: 'isPropertiesDataDynamic',
+                            },
+                            {
+                                target: 'idle',
+                                actions: ['consumeParameters', 'pushKey'],
+                                cond: (ctx, evt) => evt.data.lastEvent.token !== '/>' &&
+                                    ((!ctx.key.keyName && !evt.data.keyName) ||
+                                        (!ctx.key.defaultValue && !evt.data.defaultValue)),
+                            },
+                            {
+                                target: 'idle',
+                                actions: ['consumeParameters', 'pushKey'],
+                            },
+                        ],
+                    },
+                    on: {
+                        '*': {
+                            actions: (0, xstate_1.forwardTo)('propertiesMachine'),
+                        },
+                    },
+                },
+            },
+        },
+        t: {
+            initial: 'idle',
+            states: {
+                idle: {
+                    on: {
+                        'punctuation.definition.variable.svelte': {
+                            target: 'dollar',
+                            cond: (ctx, evt) => ctx.useTranslate !== null && evt.token === '$',
+                        },
+                    },
+                },
+                dollar: {
+                    on: {
+                        '*': 'idle',
+                        'entity.name.function.ts': {
+                            target: 'func',
+                            actions: 'storeLine',
+                            cond: (_ctx, evt) => evt.token === 't',
+                        },
+                    },
+                },
+                func: {
+                    on: {
+                        '*': 'idle',
+                        newline: undefined,
+                        'source.ts': undefined,
+                        'meta.brace.round.ts': [
+                            {
+                                target: 'idle',
+                                actions: 'consumeIgnoredLine',
+                                cond: (ctx, evt) => ctx.ignore?.line === ctx.line && evt.token === '(',
+                            },
+                            {
+                                target: 'call',
+                                cond: (_ctx, evt) => evt.token === '(',
+                            },
+                        ],
+                    },
+                },
+                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,
+                            },
+                            {
+                                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,
+                            },
+                            {
+                                target: 'idle',
+                                actions: 'dynamicKeyName',
+                            },
+                        ],
+                        'keyword.operator.arithmetic.ts': [
+                            {
+                                target: 'param_end_warn',
+                                actions: 'dynamicKeyDefault',
+                                cond: (ctx) => !!ctx.key.defaultValue,
+                            },
+                            {
+                                target: 'idle',
+                                actions: 'dynamicKeyName',
+                            },
+                        ],
+                        '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: properties_1.default,
+                        data: {
+                            depth: 1,
+                        },
+                        onDone: [
+                            {
+                                target: 'idle',
+                                actions: 'emitWarningFromParameters',
+                                cond: 'isPropertiesDataDynamic',
+                            },
+                            {
+                                target: 'idle',
+                                actions: ['consumeParameters', 'pushKey'],
+                            },
+                        ],
+                    },
+                    on: {
+                        '*': {
+                            actions: (0, xstate_1.forwardTo)('propertiesMachine'),
+                        },
+                    },
+                },
+            },
+        },
+    },
+}, {
+    guards: {
+        isPropertiesDataDynamic: (_ctx, evt) => evt.data.keyName === false || evt.data.namespace === false,
+    },
+    actions: {
+        storeLine: (0, xstate_1.assign)({
+            line: (_ctx, evt) => evt.line,
+        }),
+        ignoreNextLine: (0, xstate_1.assign)({
+            ignore: (_ctx, evt) => ({ type: 'ignore', line: evt.line + 1 }),
+        }),
+        consumeIgnoredLine: (0, xstate_1.assign)({
+            ignore: (_ctx, _evt) => null,
+        }),
+        warnUnusedIgnore: (0, xstate_1.assign)({
+            warnings: (ctx, evt) => [
+                ...ctx.warnings,
+                { warning: 'W_UNUSED_IGNORE', line: evt.line - 1 },
+            ],
+        }),
+        storeUseTranslate: (0, xstate_1.assign)({
+            useTranslate: (_ctx, _evt) => '',
+        }),
+        storeNamespacedUseTranslate: (0, xstate_1.assign)({
+            useTranslate: (_ctx, evt) => evt.token,
+        }),
+        markUseTranslateAsDynamic: (0, xstate_1.assign)({
+            useTranslate: (_ctx, _evt) => false,
+            warnings: (ctx, _evt) => [
+                ...ctx.warnings,
+                { warning: 'W_DYNAMIC_NAMESPACE', line: ctx.line },
+            ],
+        }),
+        consumeParameters: (0, xstate_1.assign)({
+            key: (ctx, evt) => ({
+                keyName: ctx.key.keyName || evt.data.keyName,
+                defaultValue: ctx.key.defaultValue || evt.data.defaultValue || undefined,
+                namespace: evt.data.namespace ?? ctx.key.namespace,
+                line: ctx.line,
+            }),
+            warnings: (ctx, evt) => {
+                if (evt.data.defaultValue !== false)
+                    return ctx.warnings;
+                return [
+                    ...ctx.warnings,
+                    { warning: 'W_DYNAMIC_DEFAULT_VALUE', line: ctx.line },
+                ];
+            },
+        }),
+        emitWarningFromParameters: (0, xstate_1.assign)({
+            warnings: (ctx, evt) => [
+                ...ctx.warnings,
+                {
+                    warning: evt.data.keyName === false
+                        ? 'W_DYNAMIC_KEY'
+                        : 'W_DYNAMIC_NAMESPACE',
+                    line: ctx.line,
+                },
+            ],
+            key: (_ctx, _evt) => VOID_KEY,
+        }),
+        storeKeyName: (0, xstate_1.assign)({
+            key: (ctx, evt) => ({ ...ctx.key, keyName: evt.token }),
+        }),
+        storeKeyDefault: (0, xstate_1.assign)({
+            key: (ctx, evt) => ({ ...ctx.key, defaultValue: evt.token }),
+        }),
+        storeKeyCurrentNamespace: (0, xstate_1.assign)({
+            key: (ctx, _evt) => ({
+                ...ctx.key,
+                namespace: ctx.useTranslate !== null ? ctx.useTranslate : undefined,
+            }),
+        }),
+        dynamicKeyName: (0, xstate_1.assign)({
+            warnings: (ctx, _evt) => [
+                ...ctx.warnings,
+                { warning: 'W_DYNAMIC_KEY', line: ctx.line },
+            ],
+            key: (_ctx, _evt) => VOID_KEY,
+        }),
+        dynamicKeyDefault: (0, xstate_1.assign)({
+            key: (ctx, _evt) => ({ ...ctx.key, defaultValue: undefined }),
+            warnings: (ctx, _evt) => [
+                ...ctx.warnings,
+                { warning: 'W_DYNAMIC_DEFAULT_VALUE', line: ctx.line },
+            ],
+        }),
+        dynamicOptions: (0, xstate_1.assign)({
+            key: (_ctx, _evt) => VOID_KEY,
+            warnings: (ctx, _evt) => [
+                ...ctx.warnings,
+                { warning: 'W_DYNAMIC_OPTIONS', line: ctx.line },
+            ],
+        }),
+        pushKey: (0, xstate_1.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;
+                return [
+                    ...ctx.keys,
+                    {
+                        keyName: ctx.key.keyName.trim(),
+                        namespace: ctx.key.namespace === ''
+                            ? undefined
+                            : ctx.key.namespace?.trim(),
+                        defaultValue: ctx.key.defaultValue?.trim().replace(/\s+/g, ' '),
+                        line: ctx.line,
+                    },
+                ];
+            },
+            key: (_ctx, _evt) => ({ keyName: '', line: 0 }),
+        }),
+        pushImmediateKey: (0, xstate_1.assign)({
+            ignore: (_ctx, evt) => ({ type: 'key', line: evt.line + 1 }),
+            keys: (ctx, evt) => [
+                ...ctx.keys,
+                {
+                    keyName: evt.keyName,
+                    namespace: evt.namespace,
+                    defaultValue: evt.defaultValue,
+                    line: evt.line,
+                },
+            ],
+        }),
+        pushWarning: (0, xstate_1.assign)({
+            warnings: (ctx, evt) => [
+                ...ctx.warnings,
+                { warning: evt.kind, line: evt.line },
+            ],
+        }),
+    },
+});

package/dist/extractor/tokenizer.js

@@ -8,6 +8,7 @@ const GRAMMAR_PATH = (0, path_1.join)(__dirname, '..', '..', 'textmate');
 const GrammarFiles = {
     ["source.ts" /* Grammar.TYPESCRIPT */]: (0, path_1.join)(GRAMMAR_PATH, 'TypeScript.tmLanguage'),
     ["source.tsx" /* Grammar.TYPESCRIPT_TSX */]: (0, path_1.join)(GRAMMAR_PATH, 'TypeScriptReact.tmLanguage'),
+    ["source.svelte" /* Grammar.SVELTE */]: (0, path_1.join)(GRAMMAR_PATH, 'Svelte.tmLanguage'),
 };
 let oniguruma;
 let registry;
@@ -27,7 +28,9 @@ async function loadGrammar(scope) {
     if (!file)
         return null;
     const grammar = await (0, promises_1.readFile)(file, 'utf8');
-    return (0, vscode_textmate_1.parseRawGrammar)(grammar);
+    return grammar.startsWith('{')
+        ? JSON.parse(grammar)
+        : (0, vscode_textmate_1.parseRawGrammar)(grammar);
 }
 function extnameToGrammar(extname) {
     switch (extname) {
@@ -41,6 +44,8 @@ function extnameToGrammar(extname) {
         case '.jsx':
         case '.tsx':
             return "source.tsx" /* Grammar.TYPESCRIPT_TSX */;
+        case '.svelte':
+            return "source.svelte" /* Grammar.SVELTE */;
     }
 }
 function tokenize(code, grammar) {

package/dist/extractor/warnings.js

@@ -66,8 +66,6 @@ function dumpWarnings(extractionResult) {
     return warningCount;
 }
 exports.dumpWarnings = dumpWarnings;
-// TODO: Revisit this function and turn it into an actual GitHub Action Annotation?
-// https://docs.github.com/en/rest/checks/runs?apiVersion=2022-11-28#update-a-check-run
 function emitGitHubWarning(warning, file, line) {
     if (!process.env.GITHUB_ACTIONS)
         return;

package/dist/extractor/worker.js

@@ -7,8 +7,7 @@ exports.callWorker = void 0;
 const path_1 = require("path");
 const worker_threads_1 = require("worker_threads");
 const promises_1 = require("fs/promises");
-// TODO: this solution won't handle new integrations and it will need a slight tweaking before adding new ones
-const react_1 = __importDefault(require("./presets/react"));
+const extractor_1 = __importDefault(require("./extractor"));
 const moduleLoader_1 = require("../utils/moduleLoader");
 const deferred_1 = require("../utils/deferred");
 const IS_TS_NODE = (0, path_1.extname)(__filename) === '.ts';
@@ -20,7 +19,7 @@ async function handleJob(args) {
         loadedExtractor = args.extractor;
         extractor = args.extractor
             ? await (0, moduleLoader_1.loadModule)(args.extractor).then((mdl) => mdl.default)
-            : react_1.default;
+            : extractor_1.default;
     }
     const file = (0, path_1.resolve)(args.file);
     const code = await (0, promises_1.readFile)(file, 'utf8');

package/dist/index.js

@@ -26,50 +26,58 @@ function topLevelName(command) {
         ? topLevelName(command.parent)
         : command.name();
 }
-async function validateApiKey(cmd) {
+async function loadApiKey(cmd) {
     const opts = cmd.optsWithGlobals();
-    if (!opts.apiKey) {
-        // Attempt to load --api-key from config store if not specified
-        // This is not done as part of the init routine or via the mandatory flag, as this is dependent on the API URL.
-        const key = await (0, credentials_1.getApiKey)(opts.apiUrl, opts.projectId);
-        if (!key) {
-            (0, logger_1.error)('No API key has been provided. You must either provide one via --api-key, or login via `tolgee login`.');
-            process.exit(1);
+    // API Key is already loaded
+    if (opts.apiKey)
+        return;
+    // Attempt to load --api-key from config store if not specified
+    // This is not done as part of the init routine or via the mandatory flag, as this is dependent on the API URL.
+    const key = await (0, credentials_1.getApiKey)(opts.apiUrl, opts.projectId);
+    // No key in store, stop here.
+    if (!key)
+        return;
+    cmd.setOptionValue('apiKey', key);
+    program.setOptionValue('_removeApiKeyFromStore', () => {
+        if (key.startsWith(constants_1.API_KEY_PAT_PREFIX)) {
+            (0, credentials_1.savePat)(opts.apiUrl);
         }
-        cmd.setOptionValue('apiKey', key);
-        program.setOptionValue('_removeApiKeyFromStore', () => {
-            if (key.startsWith(constants_1.API_KEY_PAT_PREFIX)) {
-                (0, credentials_1.savePat)(opts.apiUrl);
-            }
-            else {
-                (0, credentials_1.savePak)(opts.apiUrl, opts.projectId);
-            }
-        });
-    }
+        else {
+            (0, credentials_1.savePak)(opts.apiUrl, opts.projectId);
+        }
+    });
 }
-function validateProjectId(cmd) {
+function loadProjectId(cmd) {
     const opts = cmd.optsWithGlobals();
-    // Validate --project-id is present when using Project API keys
-    if (opts.projectId === -1 && opts.apiKey.startsWith(constants_1.API_KEY_PAT_PREFIX)) {
-        (0, logger_1.error)('You must specify a Project ID.');
-        process.exit(1);
-    }
     if (opts.apiKey.startsWith(constants_1.API_KEY_PAK_PREFIX)) {
-        // Parse the key to ensure we can access the specified Project ID
+        // Parse the key and ensure we can access the specified Project ID
         const projectId = client_1.default.projectIdFromKey(opts.apiKey);
         program.setOptionValue('projectId', projectId);
         if (opts.projectId !== -1 && opts.projectId !== projectId) {
             (0, logger_1.error)('The specified API key cannot be used to perform operations on the specified project.');
             (0, logger_1.info)(`The API key you specified is tied to project #${projectId}, you tried to perform operations on project #${opts.projectId}.`);
-            (0, logger_1.info)('Learn more about how API keys in Tolgee work here: https://tolgee.io/docs/platform/api-keys-and-pat-tokens');
+            (0, logger_1.info)('Learn more about how API keys in Tolgee work here: https://tolgee.io/platform/account_settings/api_keys_and_pat_tokens');
             process.exit(1);
         }
     }
 }
+function validateOptions(cmd) {
+    const opts = cmd.optsWithGlobals();
+    if (opts.projectId === -1) {
+        (0, logger_1.error)('No Project ID have been specified. You must either provide one via --project-ir, or by setting up a `.tolgeerc` file.');
+        (0, logger_1.info)('Learn more about configuring the CLI here: https://tolgee.io/tolgee-cli/project-configuration');
+        process.exit(1);
+    }
+    if (!opts.apiKey) {
+        (0, logger_1.error)('No API key has been provided. You must either provide one via --api-key, or login via `tolgee login`.');
+        process.exit(1);
+    }
+}
 async function preHandler(prog, cmd) {
     if (!NO_KEY_COMMANDS.includes(topLevelName(cmd))) {
-        await validateApiKey(cmd);
-        await validateProjectId(cmd);
+        await loadApiKey(cmd);
+        loadProjectId(cmd);
+        validateOptions(cmd);
         const opts = cmd.optsWithGlobals();
         const client = new client_1.default({
             apiUrl: opts.apiUrl,

package/dist/options.js

@@ -7,7 +7,7 @@ const commander_1 = require("commander");
 const constants_1 = require("./constants");
 function parseProjectId(v) {
     const val = Number(v);
-    if (isNaN(val) || val < 1) {
+    if (!Number.isInteger(val) || val < 1) {
         throw new commander_1.InvalidArgumentError('Not a valid project ID.');
     }
     return val;

package/dist/utils/moduleLoader.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadModule = void 0;
 const path_1 = require("path");
 let tsService;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function realImport(file) {
     return eval('import(file)');
 }