@tolgee/cli 2.1.8 → 2.2.0

package/dist/extractor/extractor.js

@@ -3,6 +3,7 @@ import { ParserReact } from './parserReact/ParserReact.js';
 import { tokensList } from './visualizers/printTokens.js';
 import { visualizeRules } from './visualizers/visualizeRules.js';
 import { ParserVue } from './parserVue/ParserVue.js';
+import { ParserNgx } from './parserNgx/ParserNgx.js';
 import { ParserSvelte } from './parserSvelte/ParserSvelte.js';
 function pickParser(format) {
     switch (format) {
@@ -12,6 +13,8 @@ function pickParser(format) {
             return ParserVue();
         case 'svelte':
             return ParserSvelte();
+        case 'ngx':
+            return ParserNgx();
     }
 }
 export async function extractTreeAndReport(code, fileName, parserType, options) {
@@ -33,10 +36,14 @@ export async function extractTreeAndReport(code, fileName, parserType, options)
         options,
     });
     if (debug) {
-        console.log(JSON.stringify(result.tree, null, 2));
-        console.log(tokensList(tokensMerged));
-        console.log(visualizeRules(tokensMerged, code));
-        console.log(visualizeRules(tokensWithRules, code));
+        console.log(JSON.stringify(result.tree, null, 2) +
+            '\n' +
+            tokensList(tokensMerged) +
+            '\n' +
+            visualizeRules(tokensMerged, code) +
+            '\n' +
+            visualizeRules(tokensWithRules, code) +
+            '\n');
     }
     return result;
 }

package/dist/extractor/parser/extractComment.js

@@ -14,16 +14,13 @@ function isValidKeyOverride(data) {
     }
     return true;
 }
-function getEndLine(token) {
-    return token.line + (token.token.match(/\n/gm)?.length ?? 0);
-}
 export function extractComment(token) {
-    const comment = token.token.trim();
+    const comment = token.token.replaceAll(/[^\n]([\w]*\*+)/g, '').trim();
     if (comment.startsWith('@tolgee-ignore')) {
         return {
             type: 'MAGIC_COMMENT',
             kind: 'ignore',
-            line: getEndLine(token),
+            line: token.line,
         };
     }
     if (comment.startsWith('@tolgee-key')) {
@@ -34,7 +31,7 @@ export function extractComment(token) {
                 type: 'MAGIC_COMMENT',
                 kind: 'key',
                 keyName: data.slice(1),
-                line: getEndLine(token),
+                line: token.line,
             };
         }
         // Data is a json5 struct
@@ -46,7 +43,7 @@ export function extractComment(token) {
                     return {
                         type: 'WARNING',
                         kind: 'W_INVALID_KEY_OVERRIDE',
-                        line: getEndLine(token),
+                        line: token.line,
                     };
                 }
                 else {
@@ -56,7 +53,7 @@ export function extractComment(token) {
                         keyName: key.key,
                         namespace: key.ns,
                         defaultValue: key.defaultValue,
-                        line: getEndLine(token),
+                        line: token.line,
                     };
                 }
             }
@@ -64,7 +61,7 @@ export function extractComment(token) {
                 return {
                     type: 'WARNING',
                     kind: 'W_MALFORMED_KEY_OVERRIDE',
-                    line: getEndLine(token),
+                    line: token.line,
                 };
             }
         }
@@ -72,7 +69,7 @@ export function extractComment(token) {
             type: 'MAGIC_COMMENT',
             kind: 'key',
             keyName: data,
-            line: getEndLine(token),
+            line: token.line,
         };
     }
 }

package/dist/extractor/parser/generalMapper.js

@@ -13,9 +13,9 @@ export const generalMapper = (token) => {
             return 'primitive.null';
         // plain strings
         case 'punctuation.definition.string.begin.ts':
-            return 'string.begin';
+            return 'string.quote';
         case 'punctuation.definition.string.end.ts':
-            return 'string.end';
+            return 'string.quote';
         case 'string.quoted.single.ts':
         case 'string.quoted.double.ts':
             return 'string.body';
@@ -23,9 +23,9 @@ export const generalMapper = (token) => {
             return 'escaped.character';
         // template strings
         case 'punctuation.definition.string.template.begin.ts':
-            return 'string.teplate.begin';
+            return 'string.teplate.quote';
         case 'punctuation.definition.string.template.end.ts':
-            return 'string.template.end';
+            return 'string.template.quote';
         case 'string.template.ts':
             return 'string.template.body';
         // variables

package/dist/extractor/parser/mergerMachine.js

@@ -1,13 +1,15 @@
-function defaultResultToken(matched) {
-    return matched.map((t) => t.token).join('');
-}
 const MERGE_ALL = Symbol('MERGE_ALL');
 const MERGE_WITHOUT_LAST = Symbol('MERGE_WITHOUT_LAST');
+const REPLACE_FIRST = Symbol('REPLACE_FIRST');
+const MERGE_CUSTOM = Symbol('MERGE_CUSTOM');
 export const endOptions = {
     MERGE_ALL,
     MERGE_WITHOUT_LAST,
+    REPLACE_FIRST,
+    MERGE_CUSTOM,
 };
 function createNewToken(tokens, customType, merger) {
+    const mergerData = merger?.(tokens);
     return {
         customType,
         type: 'custom',
@@ -15,7 +17,8 @@ function createNewToken(tokens, customType, merger) {
         endIndex: tokens[tokens.length - 1].endIndex,
         scopes: [],
         line: tokens[0].line,
-        token: merger(tokens),
+        token: tokens.map((t) => t.token).join(''),
+        ...mergerData,
     };
 }
 export function createMachine(machine) {
@@ -34,15 +37,43 @@ export function createMachine(machine) {
                 continue;
             }
             else if (newState === endOptions.MERGE_ALL ||
-                newState === endOptions.MERGE_WITHOUT_LAST) {
-                const lastToken = newState === endOptions.MERGE_WITHOUT_LAST ? stack.pop() : undefined;
-                const newToken = createNewToken(stack, machine.customType, machine.resultToken ?? defaultResultToken);
-                state = machine.initial;
-                stack = [];
+                newState === endOptions.MERGE_WITHOUT_LAST ||
+                newState === endOptions.REPLACE_FIRST ||
+                newState === endOptions.MERGE_CUSTOM) {
+                let before = [];
+                let toMerge;
+                let after;
+                if (newState === endOptions.MERGE_ALL) {
+                    toMerge = stack;
+                    after = [];
+                }
+                else if (newState === endOptions.MERGE_WITHOUT_LAST) {
+                    after = [stack.pop()];
+                    toMerge = stack;
+                }
+                else if (newState === endOptions.REPLACE_FIRST) {
+                    toMerge = [stack.shift()];
+                    after = stack;
+                }
+                else {
+                    if (!machine.customMerge) {
+                        throw new Error('No custom merge cpecified');
+                    }
+                    const result = machine.customMerge(stack);
+                    before = result.before;
+                    toMerge = result.toMerge;
+                    after = result.after;
+                }
+                const newToken = createNewToken(toMerge, machine.customType, machine.resultToken);
+                for (const result of before) {
+                    yield result;
+                }
                 yield newToken;
-                if (lastToken) {
-                    yield lastToken;
+                for (const result of after) {
+                    yield result;
                 }
+                stack = [];
+                state = machine.initial;
                 continue;
             }
             else {

package/dist/extractor/parser/tokenMergers/closingTagMerger.js

@@ -22,6 +22,6 @@ export const closingTagMerger = {
     },
     customType: 'tag.closing',
     resultToken: (matched) => {
-        return matched[1].token;
+        return { token: matched[1].token };
     },
 };

package/dist/extractor/parser/tokenMergers/commentsMerger.js

@@ -12,7 +12,7 @@ export const commentsMerger = {
                 if (type === 'comment.line') {
                     return end.MERGE_ALL;
                 }
-                else if (type === 'comment.block') {
+                else if (type === 'comment.block' || token.token === '\n') {
                     return 2 /* S.CommentBlock */;
                 }
                 break;
@@ -27,10 +27,13 @@ export const commentsMerger = {
         }
     },
     resultToken: (matched) => {
-        return matched
-            .filter((t) => t.customType && t.customType !== 'comment.definition')
-            .map((t) => t.token)
-            .join('');
+        return {
+            token: matched
+                .filter((t) => t.customType && t.customType !== 'comment.definition')
+                .map((t) => t.token)
+                .join(''),
+            line: matched[matched.length - 1].line,
+        };
     },
     customType: 'comment',
 };

package/dist/extractor/parser/tokenMergers/stringMerger.js

@@ -5,10 +5,10 @@ export const stringMerger = {
         const type = token.customType;
         switch (state) {
             case 0 /* S.Idle */:
-                if (type === 'string.begin') {
+                if (type === 'string.quote') {
                     return 1 /* S.RegularString */;
                 }
-                else if (type === 'string.teplate.begin') {
+                else if (type === 'string.teplate.quote') {
                     return 2 /* S.TemplateString */;
                 }
                 break;
@@ -19,7 +19,7 @@ export const stringMerger = {
                 else if (type === 'escaped.character') {
                     return 1 /* S.RegularString */;
                 }
-                else if (type === 'string.end') {
+                else if (type === 'string.quote') {
                     return end.MERGE_ALL;
                 }
                 break;
@@ -30,7 +30,7 @@ export const stringMerger = {
                 else if (type === 'escaped.character') {
                     return 2 /* S.TemplateString */;
                 }
-                else if (type === 'string.template.end') {
+                else if (type === 'string.template.quote') {
                     return end.MERGE_ALL;
                 }
                 break;
@@ -50,6 +50,6 @@ export const stringMerger = {
             }
         })
             .join('');
-        return unescape(escaped);
+        return { token: unescape(escaped) };
     },
 };

package/dist/extractor/parser/tokenMergers/templateStringMerger.js

@@ -50,6 +50,6 @@ export const templateStringMerger = {
                 result.push(token.token);
             }
         }
-        return result.join('').trim();
+        return { token: result.join('').trim() };
     },
 };

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

@@ -1,4 +1,4 @@
-function getCombinedOptions({ ns, noWrap, orEmpty, params, language, ...rest }, line) {
+export function getCombinedOptions({ ns, noWrap, orEmpty, params, language, ...rest }, line) {
     const options = {
         ns: ns,
         noWrap: noWrap,

package/dist/extractor/parserNgx/ParserNgx.js

@@ -0,0 +1,29 @@
+import { pipeMachines } from '../parser/mergerMachine.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { generalMapper } from '../parser/generalMapper.js';
+import { ngxMapper } from './ngxMapper.js';
+import { ngxTreeTransform } from './ngxTreeTransform.js';
+import { componentWithTMerger } from './tokenMergers/elementMerger.js';
+import { translateMerger } from './tokenMergers/translateMerger.js';
+import { pipeMerger } from './tokenMergers/pipeMerger.js';
+import { componentWithT } from './rules/componentWithT.js';
+import { translatePipe } from './rules/translatePipe.js';
+import { translateFunction } from './rules/translateFunction.js';
+const ngxMappers = [ngxMapper, generalMapper];
+export const ngxMergers = pipeMachines([
+    ...DEFAULT_MERGERERS,
+    componentWithTMerger,
+    pipeMerger,
+    translateMerger,
+]);
+export const ParserNgx = () => {
+    return Parser({
+        mappers: ngxMappers,
+        blocks: {
+            ...DEFAULT_BLOCKS,
+        },
+        rules: [componentWithT, translatePipe, translateFunction],
+        merger: ngxMergers,
+        treeTransform: ngxTreeTransform,
+    });
+};

package/dist/extractor/parserNgx/ngxMapper.js

@@ -0,0 +1,67 @@
+export const ngxMapper = (token) => {
+    switch (token.type) {
+        // ngx template tags
+        case 'punctuation.definition.tag.begin.html':
+            return token.token === '</' ? 'tag.closing.begin' : 'tag.regular.begin';
+        case 'punctuation.definition.tag.end.html':
+            return token.token === '/>' ? 'tag.self-closing.end' : 'tag.regular.end';
+        case 'html-template.tag.html':
+            return 'tag.name';
+        case 'html-template.ng.attributes.generic':
+            return 'tag.attribute.name';
+        case 'punctuation.separator.key-value.html-template.ng':
+            return 'operator.assignment';
+        case 'entity.other.attribute-name.html':
+            return 'tag.attribute.name';
+        case 'punctuation.separator.key-value.html':
+            return 'operator.assignment';
+        // html string attributes
+        case 'punctuation.definition.string.begin.html':
+            return 'string.quote';
+        case 'punctuation.definition.string.end.html':
+            return 'string.quote';
+        case 'string.quoted.single.html':
+        case 'string.quoted.double.html':
+            if (token.token === '"' || token.token === "'") {
+                // ignoring qotes around strings and expressions
+                // we can just take the content without them
+                // as otherwise we would need to distinguish if it's an expression or string
+                // (angular grammar doesn't do this for some reason)
+                return 'ignore';
+            }
+            else {
+                return 'string';
+            }
+        case 'string.unquoted.html':
+            return 'string';
+        case 'html-template.ng.attributes.input-binding.first-level':
+        case 'html-template.ng.attributes.event-handler':
+            return 'tag.attribute.name';
+        case 'punctuation.definition.ng-binding-name.begin.html':
+        case 'punctuation.definition.ng-binding-name.end.html':
+            // ignoring binding brackets, irrelevant for us
+            return 'ignore';
+        // html comments
+        case 'punctuation.definition.comment.begin.html':
+        case 'punctuation.definition.comment.end.html':
+        case 'punctuation.definition.comment.html':
+            return 'comment.definition';
+        case 'comment.block.html':
+            return 'comment.block';
+        // pipeline operators
+        case 'html-template.ng.expression.operator.logical':
+            return 'operator.logical';
+        case 'html-template.ng.expression.operator.navigator':
+            return 'operator.navigator';
+        case 'variable.other.property.ts':
+        case 'entity.name.function.pipe.ng':
+            return 'function.call.pipe';
+        case 'variable.other.object.property.ts':
+            return 'variable';
+        // angular interpolation
+        case 'html-template.ng.interpolation.begin':
+            return 'expression.template.begin';
+        case 'html-template.ng.interpolation.end':
+            return 'expression.template.end';
+    }
+};

package/dist/extractor/parserNgx/ngxTreeTransform.js

@@ -0,0 +1,46 @@
+import { simplifyNode } from '../parser/nodeUtils.js';
+function transformRecursive(root) {
+    if (!root) {
+        return;
+    }
+    switch (root.type) {
+        case 'expr':
+        case 'array':
+            root.values.forEach((item, i) => {
+                if (item.type === 'keyInfo' && item.keyName === undefined) {
+                    const nodeBefore = simplifyNode(root.values[i - 1]);
+                    if (nodeBefore.type === 'dict') {
+                        item.keyName = nodeBefore.value['key'];
+                        item.namespace = nodeBefore.value['ns'] ?? item.namespace;
+                        item.defaultValue =
+                            nodeBefore.value['defaultValue'] ?? item.defaultValue;
+                    }
+                    else {
+                        item.keyName = nodeBefore;
+                    }
+                }
+                transformRecursive(item);
+            });
+            break;
+        case 'dict':
+            Object.values(root.value).forEach(transformRecursive);
+            root.unknown.forEach(transformRecursive);
+            break;
+        case 'keyInfo':
+            transformRecursive(root.defaultValue);
+            transformRecursive(root.keyName);
+            transformRecursive(root.namespace);
+            root.values.forEach(transformRecursive);
+            break;
+        case 'nsInfo':
+            transformRecursive(root.name);
+            root.values.forEach(transformRecursive);
+            break;
+        case 'primitive':
+            return;
+    }
+}
+export const ngxTreeTransform = (root) => {
+    transformRecursive(root);
+    return { tree: root, report: { keys: [], warnings: [] } };
+};

package/dist/extractor/parserNgx/rules/componentWithT.js

@@ -0,0 +1,43 @@
+import { parseTag } from '../../parser/tree/parseTag.js';
+// <div t key="test"></div>
+// ^-----------------^^^^^^
+export const componentWithT = {
+    trigger: 'trigger.component.with.t',
+    call(context) {
+        const { getCurrentLine } = context;
+        const line = getCurrentLine();
+        context.tokens.next();
+        const { props, child } = parseTag(context);
+        if (props.type !== 'dict' || !props.value['t']) {
+            const result = { type: 'array', line, values: [props] };
+            if (child) {
+                result.values.push(child);
+            }
+            return result;
+        }
+        else {
+            const result = {
+                type: 'keyInfo',
+                line,
+                dependsOnContext: false,
+                values: [],
+            };
+            for (const [key, value] of Object.entries(props.value)) {
+                switch (key) {
+                    case 'key':
+                        result.keyName = value;
+                        break;
+                    case 'default':
+                        result.defaultValue = value;
+                        break;
+                    case 'ns':
+                        result.namespace = value;
+                        break;
+                    default:
+                        result.values.push(value);
+                }
+            }
+            return result;
+        }
+    },
+};

package/dist/extractor/parserNgx/rules/helpers/parsePipeArgs.js

@@ -0,0 +1,26 @@
+import { parseGeneral } from '../../../../extractor/parser/tree/parseGeneral.js';
+/*
+ * :{ noWrap: true }:'item'
+ * ^----------------------^
+ */
+export function parsePipeArgs(context, end) {
+    const { tokens, getCurrentLine } = context;
+    const line = getCurrentLine();
+    const result = { type: 'array', line, values: [] };
+    let token;
+    while ((token = tokens.current())) {
+        if (end.includes(token.customType)) {
+            break;
+        }
+        switch (token.customType) {
+            case 'operator.navigator':
+                tokens.next();
+                break;
+            default:
+                result.values.push(parseGeneral(context, {
+                    end: ['operator.navigator', ...end],
+                }));
+        }
+    }
+    return result;
+}

package/dist/extractor/parserNgx/rules/translateFunction.js

@@ -0,0 +1,7 @@
+import { tFunctionGeneral } from '../../parser/rules/tFunctionGeneral.js';
+export const translateFunction = {
+    trigger: 'trigger.translate.function',
+    call(context) {
+        return tFunctionGeneral(context, false);
+    },
+};

package/dist/extractor/parserNgx/rules/translatePipe.js

@@ -0,0 +1,57 @@
+import { isString } from '../../../extractor/parser/nodeUtils.js';
+import { parsePipeArgs } from './helpers/parsePipeArgs.js';
+// <div title={{'test' | translate:{noWrap: true}:'default value'}}></div>
+//                     ^^^^^^^^^^^----------------^^^^^^^^^^^^^^^
+export const translatePipe = {
+    trigger: 'trigger.translate.pipe',
+    call(context) {
+        const { tokens, getCurrentLine } = context;
+        const line = getCurrentLine();
+        tokens.next();
+        const args = parsePipeArgs(context, [
+            'operator.logical',
+            'expression.template.end',
+            'expression.end',
+            'tag.regular.end',
+            'tag.self-closing.end',
+            'tag.attribute.name',
+        ]);
+        const keyNode = {
+            type: 'keyInfo',
+            line,
+            keyName: undefined,
+            dependsOnContext: false,
+            values: [],
+        };
+        let options = undefined;
+        if (args.values.length === 1) {
+            if (isString(args.values[0])) {
+                keyNode.defaultValue = args.values[0];
+            }
+            else {
+                options = args.values[0];
+            }
+        }
+        else if (args.values.length > 1) {
+            options = args.values.shift();
+            keyNode.defaultValue = args.values.shift();
+            keyNode.values = args.values;
+        }
+        if (options?.type === 'dict') {
+            for (const [key, value] of Object.entries(options.value)) {
+                switch (key) {
+                    case 'ns':
+                        keyNode.namespace = value;
+                        break;
+                    default:
+                        // unknown parameter
+                        keyNode.values.push(value);
+                }
+            }
+        }
+        else if (options) {
+            keyNode.optionsDynamic = true;
+        }
+        return keyNode;
+    },
+};

package/dist/extractor/parserNgx/tokenMergers/elementMerger.js

@@ -0,0 +1,29 @@
+// <div ... t
+export const componentWithTMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'tag.regular.begin') {
+                    return 1 /* S.ExpectName */;
+                }
+                break;
+            case 1 /* S.ExpectName */:
+                if (type === 'tag.name') {
+                    return 2 /* S.ExpectTParam */;
+                }
+                break;
+            case 2 /* S.ExpectTParam */:
+                if (type === 'tag.attribute.name' && t.token === 't') {
+                    return end.REPLACE_FIRST;
+                }
+                else if (type === 'tag.self-closing.end' ||
+                    type === 'tag.regular.end') {
+                    return undefined;
+                }
+                return 2 /* S.ExpectTParam */;
+        }
+    },
+    customType: 'trigger.component.with.t',
+};

package/dist/extractor/parserNgx/tokenMergers/pipeMerger.js

@@ -0,0 +1,19 @@
+// <div ... t
+export const pipeMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'operator.logical') {
+                    return 1 /* S.ExpectTranslate */;
+                }
+                break;
+            case 1 /* S.ExpectTranslate */:
+                if (type === 'function.call.pipe' && t.token === 'translate') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.translate.pipe',
+};

package/dist/extractor/parserNgx/tokenMergers/translateMerger.js

@@ -0,0 +1,41 @@
+const SERVICE_NAME_POSSIBILITIES = ['translateService'];
+const TRANSLATE_FUNCTION_NAMES = ['translate', 'instant', 'get'];
+// translateService.translate('key1', 'default-1', { ns: 'ns-1' })
+export const translateMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        const token = t.token;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (['variable', 'function.call.pipe'].includes(type) &&
+                    SERVICE_NAME_POSSIBILITIES.includes(token)) {
+                    return 2 /* S.ExpectDot */;
+                }
+                break;
+            case 2 /* S.ExpectDot */:
+                if (type === 'acessor.dot') {
+                    return 3 /* S.ExpectCall */;
+                }
+                break;
+            case 3 /* S.ExpectCall */:
+                if (type === 'function.call' &&
+                    TRANSLATE_FUNCTION_NAMES.includes(token)) {
+                    return 1 /* S.ExpectBracket */;
+                }
+                break;
+            case 1 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_CUSTOM;
+                }
+        }
+    },
+    customType: 'trigger.translate.function',
+    customMerge(tokens) {
+        return {
+            before: tokens.slice(0, -2),
+            toMerge: tokens.slice(-2),
+            after: [],
+        };
+    },
+};