@tolgee/cli 1.0.2 → 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

@@ -56,7 +56,7 @@ function loadProjectId(cmd) {
         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);
         }
     }

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)');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolgee/cli",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "type": "commonjs",
   "description": "A tool to interact with the Tolgee Platform through CLI",
   "bin": {
@@ -10,14 +10,14 @@
     "build": "rimraf dist dist-types && tsc && cp dist-types/extractor/index.d.ts extractor.d.ts",
     "test": "npm run test:unit && npm run test:e2e && npm run test:package",
     "test:unit": "jest -c jest.unit.config.ts",
-    "pretest:e2e": "npm run tolgee:start",
+    "pretest:e2e": "npm run build && npm run tolgee:start",
     "posttest:e2e": "npm run tolgee:stop",
     "test:e2e": "jest -c jest.e2e.config.ts --runInBand",
     "test:e2e-run": "jest -c jest.e2e.config.ts --runInBand",
     "test:package": "node scripts/validatePackage.mjs",
     "tolgee:start": "node scripts/startDocker.mjs",
     "tolgee:stop": "docker stop tolgee_cli_e2e",
-    "lint": "prettier --check ./src ./test ./scripts jest.config.ts jest.*.config.ts",
+    "lint": "eslint --ext .ts --ext .js --ext .mjs ./src ./test ./scripts jest.config.ts jest.*.config.ts",
     "prettier": "prettier --write ./src ./test ./scripts jest.config.ts jest.*.config.ts",
     "run-dev": "ts-node ./src/index.ts",
     "schema": "openapi-typescript http://localhost:22222/v3/api-docs/All%20Internal%20-%20for%20Tolgee%20Web%20application --output src/client/internal/schema.generated.ts",
@@ -47,7 +47,13 @@
     "@types/jest": "^29.2.5",
     "@types/node": "^18.11.18",
     "@types/yauzl": "^2.10.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "eslint": "^8.39.0",
+    "eslint-plugin-jest": "^27.2.1",
+    "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.3.1",
+    "js-yaml": "^4.1.0",
     "openapi-typescript": "^6.1.0",
     "prettier": "^2.8.3",
     "rimraf": "^4.0.7",