@tolgee/cli 2.8.4 → 2.10.0

package/dist/config/credentials.js

@@ -1,123 +1,140 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { join, dirname } from 'path';
 import { mkdir, readFile, writeFile } from 'fs/promises';
 import { warn } from '../utils/logger.js';
 import { CONFIG_PATH } from '../constants.js';
 const API_TOKENS_FILE = join(CONFIG_PATH, 'authentication.json');
-async function ensureConfigPath() {
-    try {
-        await mkdir(dirname(API_TOKENS_FILE));
-    }
-    catch (e) {
-        if (e.code !== 'EEXIST') {
-            throw e;
+function ensureConfigPath() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield mkdir(dirname(API_TOKENS_FILE));
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST') {
+                throw e;
+            }
         }
-    }
+    });
 }
-export async function loadStore() {
-    try {
-        await ensureConfigPath();
-        const storeData = await readFile(API_TOKENS_FILE, 'utf8');
-        return JSON.parse(storeData);
-    }
-    catch (e) {
-        if (e.code !== 'ENOENT') {
-            throw e;
+export function loadStore() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield ensureConfigPath();
+            const storeData = yield readFile(API_TOKENS_FILE, 'utf8');
+            return JSON.parse(storeData);
         }
-    }
-    return {};
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                throw e;
+            }
+        }
+        return {};
+    });
 }
-async function saveStore(store) {
-    const blob = JSON.stringify(store);
-    await writeFile(API_TOKENS_FILE, blob, {
-        mode: 0o600,
-        encoding: 'utf8',
+function saveStore(store) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const blob = JSON.stringify(store);
+        yield writeFile(API_TOKENS_FILE, blob, {
+            mode: 0o600,
+            encoding: 'utf8',
+        });
     });
 }
-async function storePat(store, instance, pat) {
-    return saveStore({
-        ...store,
-        [instance.hostname]: {
-            ...(store[instance.hostname] || {}),
-            user: pat,
-        },
+function storePat(store, instance, pat) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return saveStore(Object.assign(Object.assign({}, store), { [instance.hostname]: Object.assign(Object.assign({}, (store[instance.hostname] || {})), { user: pat }) }));
     });
 }
-async function storePak(store, instance, project, pak) {
-    return saveStore({
-        ...store,
-        [instance.hostname]: {
-            ...(store[instance.hostname] || {}),
-            projects: {
-                ...(store[instance.hostname]?.projects || {}),
-                [project.id.toString(10)]: pak,
-            },
-            projectDetails: {
-                ...(store[instance.hostname]?.projectDetails || {}),
-                [project.id.toString(10)]: { name: project.name },
-            },
-        },
+function storePak(store, instance, project, pak) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        return saveStore(Object.assign(Object.assign({}, store), { [instance.hostname]: Object.assign(Object.assign({}, (store[instance.hostname] || {})), { projects: Object.assign(Object.assign({}, (((_a = store[instance.hostname]) === null || _a === void 0 ? void 0 : _a.projects) || {})), { [project.id.toString(10)]: pak }), projectDetails: Object.assign(Object.assign({}, (((_b = store[instance.hostname]) === null || _b === void 0 ? void 0 : _b.projectDetails) || {})), { [project.id.toString(10)]: { name: project.name } }) }) }));
     });
 }
-async function removePak(store, instance, projectId) {
-    delete store[instance.hostname].projects?.[projectId.toString(10)];
-    delete store[instance.hostname].projectDetails?.[projectId.toString(10)];
-    return saveStore(store);
+function removePak(store, instance, projectId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        (_a = store[instance.hostname].projects) === null || _a === void 0 ? true : delete _a[projectId.toString(10)];
+        (_b = store[instance.hostname].projectDetails) === null || _b === void 0 ? true : delete _b[projectId.toString(10)];
+        return saveStore(store);
+    });
 }
-export async function savePat(instance, pat) {
-    const store = await loadStore();
-    return storePat(store, instance, pat);
+export function savePat(instance, pat) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const store = yield loadStore();
+        return storePat(store, instance, pat);
+    });
 }
-export async function savePak(instance, project, pak) {
-    const store = await loadStore();
-    return storePak(store, instance, project, pak);
+export function savePak(instance, project, pak) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const store = yield loadStore();
+        return storePak(store, instance, project, pak);
+    });
 }
-export async function getApiKey(instance, projectId) {
-    const store = await loadStore();
-    if (!store[instance.hostname]) {
-        return null;
-    }
-    const scopedStore = store[instance.hostname];
-    if (scopedStore.user) {
-        if (scopedStore.user.expires !== 0 &&
-            Date.now() > scopedStore.user.expires) {
-            warn(`Your personal access token for ${instance.hostname} expired.`);
-            await storePat(store, instance, undefined);
+export function getApiKey(instance, projectId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const store = yield loadStore();
+        if (!store[instance.hostname]) {
             return null;
         }
-        return scopedStore.user.token;
-    }
-    if (projectId <= 0) {
-        return null;
-    }
-    const pak = scopedStore.projects?.[projectId.toString(10)];
-    if (pak) {
-        if (pak.expires !== 0 && Date.now() > pak.expires) {
-            warn(`Your project API key for project #${projectId} on ${instance.hostname} expired.`);
-            await removePak(store, instance, projectId);
+        const scopedStore = store[instance.hostname];
+        if (scopedStore.user) {
+            if (scopedStore.user.expires !== 0 &&
+                Date.now() > scopedStore.user.expires) {
+                warn(`Your personal access token for ${instance.hostname} expired.`);
+                yield storePat(store, instance, undefined);
+                return null;
+            }
+            return scopedStore.user.token;
+        }
+        if (projectId <= 0) {
             return null;
         }
-        return pak.token;
-    }
-    return null;
+        const pak = (_a = scopedStore.projects) === null || _a === void 0 ? void 0 : _a[projectId.toString(10)];
+        if (pak) {
+            if (pak.expires !== 0 && Date.now() > pak.expires) {
+                warn(`Your project API key for project #${projectId} on ${instance.hostname} expired.`);
+                yield removePak(store, instance, projectId);
+                return null;
+            }
+            return pak.token;
+        }
+        return null;
+    });
 }
-export async function saveApiKey(instance, token) {
-    const store = await loadStore();
-    if (token.type === 'PAT') {
-        return storePat(store, instance, {
+export function saveApiKey(instance, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const store = yield loadStore();
+        if (token.type === 'PAT') {
+            return storePat(store, instance, {
+                token: token.key,
+                expires: token.expires,
+            });
+        }
+        return storePak(store, instance, token.project, {
             token: token.key,
             expires: token.expires,
         });
-    }
-    return storePak(store, instance, token.project, {
-        token: token.key,
-        expires: token.expires,
     });
 }
-export async function removeApiKeys(api) {
-    const store = await loadStore();
-    delete store[api.hostname];
-    return saveStore(store);
+export function removeApiKeys(api) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const store = yield loadStore();
+        delete store[api.hostname];
+        return saveStore(store);
+    });
 }
-export async function clearAuthStore() {
-    return saveStore({});
+export function clearAuthStore() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return saveStore({});
+    });
 }

package/dist/config/tolgeerc.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { Validator } from 'jsonschema';
 import { readFile } from 'fs/promises';
@@ -5,18 +14,20 @@ import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
 import { error, exitWithError } from '../utils/logger.js';
 import { existsSync } from 'fs';
+import { valueToArray } from '../utils/valueToArray.js';
 const explorer = cosmiconfig('tolgee', {
     loaders: {
         noExt: defaultLoaders['.json'],
     },
 });
 function parseConfig(input, configDir) {
-    const rc = { ...input };
+    var _a, _b, _c, _d;
+    const rc = Object.assign({}, input);
     if (rc.apiUrl !== undefined) {
         try {
             new URL(rc.apiUrl);
         }
-        catch {
+        catch (_e) {
             throw new Error('Invalid config: apiUrl is an invalid URL');
         }
     }
@@ -38,46 +49,51 @@ function parseConfig(input, configDir) {
         rc.patterns = rc.patterns.map((pattern) => resolve(configDir, pattern).replace(/\\/g, '/'));
     }
     // convert relative paths in config to absolute
-    if (rc.push?.files) {
-        rc.push.files = rc.push.files.map((r) => ({
-            ...r,
-            path: resolve(configDir, r.path).replace(/\\/g, '/'),
-        }));
+    if ((_a = rc.push) === null || _a === void 0 ? void 0 : _a.files) {
+        rc.push.files = rc.push.files.map((r) => (Object.assign(Object.assign({}, r), { path: resolve(configDir, r.path).replace(/\\/g, '/') })));
     }
     // convert relative paths in config to absolute
-    if (rc.pull?.path !== undefined) {
+    if ((_b = rc.push) === null || _b === void 0 ? void 0 : _b.filesTemplate) {
+        rc.push.filesTemplate = (_c = valueToArray(rc.push.filesTemplate)) === null || _c === void 0 ? void 0 : _c.map((template) => resolve(configDir, template).replace(/\\/g, '/'));
+    }
+    // convert relative paths in config to absolute
+    if (((_d = rc.pull) === null || _d === void 0 ? void 0 : _d.path) !== undefined) {
         rc.pull.path = resolve(configDir, rc.pull.path).replace(/\\/g, '/');
     }
     return rc;
 }
-async function getSchema() {
-    const path = join(fileURLToPath(new URL('.', import.meta.url)), '..', '..', 'schema.json');
-    return JSON.parse((await readFile(path)).toString());
+function getSchema() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = join(fileURLToPath(new URL('.', import.meta.url)), '..', '..', 'schema.json');
+        return JSON.parse((yield readFile(path)).toString());
+    });
 }
-export default async function loadTolgeeRc(path) {
-    let res;
-    if (path) {
-        try {
-            res = await explorer.load(path);
+export default function loadTolgeeRc(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let res;
+        if (path) {
+            try {
+                res = yield explorer.load(path);
+            }
+            catch (e) {
+                error(e.message);
+                throw new Error(`Can't open config file on path "${path}"`);
+            }
         }
-        catch (e) {
-            error(e.message);
-            throw new Error(`Can't open config file on path "${path}"`);
+        else {
+            res = yield explorer.search();
         }
-    }
-    else {
-        res = await explorer.search();
-    }
-    if (!res || res.isEmpty)
-        return null;
-    const config = parseConfig(res.config, dirname(path || '.'));
-    const validator = new Validator();
-    const schema = await getSchema();
-    const result = validator.validate(config, schema);
-    if (result.errors.length) {
-        const { message, property } = result.errors[0];
-        const errMessage = `Tolgee config: '${property.replace('instance.', '')}' ${message}`;
-        exitWithError(errMessage);
-    }
-    return config;
+        if (!res || res.isEmpty)
+            return null;
+        const config = parseConfig(res.config, dirname(path || '.'));
+        const validator = new Validator();
+        const schema = yield getSchema();
+        const result = validator.validate(config, schema);
+        if (result.errors.length) {
+            const { message, property } = result.errors[0];
+            const errMessage = `Tolgee config: '${property.replace('instance.', '')}' ${message}`;
+            exitWithError(errMessage);
+        }
+        return config;
+    });
 }

package/dist/extractor/extractor.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import tokenizer from './tokenizer.js';
 import { ParserReact } from './parserReact/ParserReact.js';
 import { tokensList } from './visualizers/printTokens.js';
@@ -17,37 +26,42 @@ function pickParser(format) {
             return ParserNgx();
     }
 }
-export async function extractTreeAndReport(code, fileName, parserType, options) {
-    const debug = options.verbose?.includes('extractor');
-    const tokens = (await tokenizer(code, fileName));
-    const parser = pickParser(parserType);
-    const tokensMerged = [];
-    const tokensWithRules = [];
-    let onAccept = undefined;
-    if (debug) {
-        onAccept = (token, type) => {
-            tokensMerged.push(token);
-            tokensWithRules.push({ ...token, customType: type });
-        };
-    }
-    const result = parser.parse({
-        tokens,
-        onAccept,
-        options,
+export function extractTreeAndReport(code, fileName, parserType, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const debug = (_a = options.verbose) === null || _a === void 0 ? void 0 : _a.includes('extractor');
+        const tokens = (yield tokenizer(code, fileName));
+        const parser = pickParser(parserType);
+        const tokensMerged = [];
+        const tokensWithRules = [];
+        let onAccept = undefined;
+        if (debug) {
+            onAccept = (token, type) => {
+                tokensMerged.push(token);
+                tokensWithRules.push(Object.assign(Object.assign({}, token), { customType: type }));
+            };
+        }
+        const result = parser.parse({
+            tokens,
+            onAccept,
+            options,
+        });
+        if (debug) {
+            console.log(JSON.stringify(result.tree, null, 2) +
+                '\n' +
+                tokensList(tokensMerged) +
+                '\n' +
+                visualizeRules(tokensMerged, code) +
+                '\n' +
+                visualizeRules(tokensWithRules, code) +
+                '\n');
+        }
+        return result;
     });
-    if (debug) {
-        console.log(JSON.stringify(result.tree, null, 2) +
-            '\n' +
-            tokensList(tokensMerged) +
-            '\n' +
-            visualizeRules(tokensMerged, code) +
-            '\n' +
-            visualizeRules(tokensWithRules, code) +
-            '\n');
-    }
-    return result;
 }
-export default async function extractor(code, fileName, parserType, options) {
-    const result = await extractTreeAndReport(code, fileName, parserType, options);
-    return result.report;
+export default function extractor(code, fileName, parserType, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield extractTreeAndReport(code, fileName, parserType, options);
+        return result.report;
+    });
 }

package/dist/extractor/parser/extractComment.js

@@ -57,7 +57,7 @@ export function extractComment(token) {
                     };
                 }
             }
-            catch {
+            catch (_a) {
                 return {
                     type: 'WARNING',
                     kind: 'W_MALFORMED_KEY_OVERRIDE',

package/dist/extractor/parser/generateReport.js

@@ -1,7 +1,7 @@
 import { extractString, isString } from './nodeUtils.js';
 function shouldBeIgnored(context, line) {
     const commentAtLine = context.commentMap.get(line - 1);
-    const isIgnore = commentAtLine?.type === 'MAGIC_COMMENT' && commentAtLine.kind === 'ignore';
+    const isIgnore = (commentAtLine === null || commentAtLine === void 0 ? void 0 : commentAtLine.type) === 'MAGIC_COMMENT' && commentAtLine.kind === 'ignore';
     if (isIgnore) {
         context.unusedComments.delete(commentAtLine);
     }
@@ -9,7 +9,7 @@ function shouldBeIgnored(context, line) {
 }
 function commentKeyInfoOnLine(context, line) {
     const commentAtLine = context.commentMap.get(line - 1);
-    const isKeyInfo = commentAtLine?.type === 'MAGIC_COMMENT' && commentAtLine.kind === 'key';
+    const isKeyInfo = (commentAtLine === null || commentAtLine === void 0 ? void 0 : commentAtLine.type) === 'MAGIC_COMMENT' && commentAtLine.kind === 'key';
     if (isKeyInfo) {
         context.unusedComments.delete(commentAtLine);
         return keyInfoFromComment(context, commentAtLine);
@@ -17,14 +17,16 @@ function commentKeyInfoOnLine(context, line) {
     return undefined;
 }
 function keyInfoFromComment(context, info) {
+    var _a;
     return {
         keyName: info.keyName,
-        namespace: info.namespace ?? context.options.defaultNamespace,
+        namespace: (_a = info.namespace) !== null && _a !== void 0 ? _a : context.options.defaultNamespace,
         defaultValue: info.defaultValue,
         line: info.line,
     };
 }
 function reportKey(context, node, contextNs) {
+    var _a;
     const { strictNamespace, defaultNamespace } = context.options;
     const { keys, warnings } = context;
     const { keyName, namespace: keyNs, defaultValue, line, dependsOnContext, optionsDynamic, } = node;
@@ -52,10 +54,10 @@ function reportKey(context, node, contextNs) {
         warnings.push({ line, warning: 'W_DYNAMIC_OPTIONS' });
         return;
     }
-    const namespace = keyNs ?? (dependsOnContext ? contextNs?.name : undefined);
+    const namespace = keyNs !== null && keyNs !== void 0 ? keyNs : (dependsOnContext ? contextNs === null || contextNs === void 0 ? void 0 : contextNs.name : undefined);
     if (namespace && !isString(namespace)) {
         // namespace is dynamic
-        if (namespace === contextNs?.name) {
+        if (namespace === (contextNs === null || contextNs === void 0 ? void 0 : contextNs.name)) {
             // namespace coming from context
             warnings.push({ line, warning: 'W_UNRESOLVABLE_NAMESPACE' });
         }
@@ -75,7 +77,7 @@ function reportKey(context, node, contextNs) {
     keys.push({
         line,
         keyName: extractString(keyName),
-        namespace: extractString(namespace) ?? defaultNamespace,
+        namespace: (_a = extractString(namespace)) !== null && _a !== void 0 ? _a : defaultNamespace,
         defaultValue: extractString(defaultValue),
     });
 }

package/dist/extractor/parser/iterator.js

@@ -6,7 +6,8 @@ export const createIterator = (items) => {
     let currentContext = undefined;
     const self = {
         getLineNumber() {
-            return currentItem?.line ?? 0;
+            var _a;
+            return (_a = currentItem === null || currentItem === void 0 ? void 0 : currentItem.line) !== null && _a !== void 0 ? _a : 0;
         },
         current() {
             return currentItem;

package/dist/extractor/parser/mergerMachine.js

@@ -9,17 +9,8 @@ export const endOptions = {
     MERGE_CUSTOM,
 };
 function createNewToken(tokens, customType, merger) {
-    const mergerData = merger?.(tokens);
-    return {
-        customType,
-        type: 'custom',
-        startIndex: tokens[0].startIndex,
-        endIndex: tokens[tokens.length - 1].endIndex,
-        scopes: [],
-        line: tokens[0].line,
-        token: tokens.map((t) => t.token).join(''),
-        ...mergerData,
-    };
+    const mergerData = merger === null || merger === void 0 ? void 0 : merger(tokens);
+    return Object.assign({ customType, type: 'custom', startIndex: tokens[0].startIndex, endIndex: tokens[tokens.length - 1].endIndex, scopes: [], line: tokens[0].line, token: tokens.map((t) => t.token).join('') }, mergerData);
 }
 export function createMachine(machine) {
     function* generator(tokens) {

package/dist/extractor/parser/nodeUtils.js

@@ -14,7 +14,7 @@ export function extractValue(node) {
     return node && node.type === 'primitive' ? node.value : undefined;
 }
 export function simplifyNode(node) {
-    if (node?.type === 'expr' && node.values.length === 1) {
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'expr' && node.values.length === 1) {
         return node.values[0];
     }
     return node;

package/dist/extractor/parser/parser.js

@@ -37,9 +37,10 @@ export const Parser = ({ mappers, blocks, rules, merger, treeTransform, }) => {
     }
     return {
         parse({ tokens, onAccept, options }) {
+            var _a;
             for (const t of tokens) {
                 // use first mapper, which gives some result
-                const type = mappers.find((mapper) => mapper(t))?.(t);
+                const type = (_a = mappers.find((mapper) => mapper(t))) === null || _a === void 0 ? void 0 : _a(t);
                 t.customType = type;
             }
             const mergedComments = [...createMachine(commentsMerger)(tokens)];
@@ -79,8 +80,9 @@ export const Parser = ({ mappers, blocks, rules, merger, treeTransform, }) => {
             let depth = 0;
             function withLabel(fn) {
                 return (...args) => {
+                    var _a;
                     let label;
-                    const currentTokenName = context.tokens.current()?.customType || '';
+                    const currentTokenName = ((_a = context.tokens.current()) === null || _a === void 0 ? void 0 : _a.customType) || '';
                     const isTrigger = currentTokenName.startsWith('trigger.');
                     if (!isTrigger) {
                         depth += 1;

package/dist/extractor/parser/rules/tNsSourceGeneral.js

@@ -21,7 +21,7 @@ export const tNsSourceGeneral = (context) => {
         values: [],
     };
     const [firstArg, ...otherArgs] = args.values;
-    if (firstArg?.type === 'array') {
+    if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'array') {
         // useTranslate(['namespace', ...])
         const [firstItem, ...otherItems] = firstArg.values;
         result.name = firstItem;

package/dist/extractor/parser/tree/getTranslateProps.js

@@ -1,23 +1,31 @@
-export function getCombinedOptions({ ns, noWrap, orEmpty, params, language, ...rest }, line) {
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+export function getCombinedOptions(_a, line) {
+    var { ns, noWrap, orEmpty, params, language } = _a, rest = __rest(_a, ["ns", "noWrap", "orEmpty", "params", "language"]);
     const options = {
         ns: ns,
         noWrap: noWrap,
         orEmpty: orEmpty,
         language: language,
     };
-    return {
-        ...options,
-        params: {
+    return Object.assign(Object.assign({}, options), { params: {
             type: 'dict',
             line,
-            value: {
-                ...rest,
-            },
+            value: Object.assign({}, rest),
             unknown: [],
-        },
-    };
+        } });
 }
 export const getTranslateProps = (node) => {
+    var _a;
     const [keyOrProps, ...params] = node.values;
     let result = {
         type: 'dict',
@@ -26,12 +34,12 @@ export const getTranslateProps = (node) => {
         unknown: [],
     };
     let options = undefined;
-    if (keyOrProps?.type === 'dict') {
+    if ((keyOrProps === null || keyOrProps === void 0 ? void 0 : keyOrProps.type) === 'dict') {
         result = keyOrProps;
     }
     else {
         result.value.key = keyOrProps;
-        if (params[0]?.type === 'primitive' || params.length >= 2) {
+        if (((_a = params[0]) === null || _a === void 0 ? void 0 : _a.type) === 'primitive' || params.length >= 2) {
             result.value.defaultValue = params[0];
             options = params[1];
         }
@@ -40,11 +48,8 @@ export const getTranslateProps = (node) => {
         }
     }
     let optionsDynamic = false;
-    if (options?.type === 'dict') {
-        result.value = {
-            ...getCombinedOptions(options.value, options.line),
-            ...result.value,
-        };
+    if ((options === null || options === void 0 ? void 0 : options.type) === 'dict') {
+        result.value = Object.assign(Object.assign({}, getCombinedOptions(options.value, options.line)), result.value);
         result.unknown.push(...options.unknown);
     }
     else if (options) {