@tolgee/cli 2.0.3 → 2.1.0

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

@@ -0,0 +1,17 @@
+import { parseGeneral } from './parseGeneral.js';
+export function getValue(context) {
+    const token = context.tokens.current();
+    const line = context.getCurrentLine();
+    switch (token?.customType) {
+        case 'string':
+        case 'primitive.null':
+            return { type: 'primitive', line, value: token.token };
+        case 'expression.begin':
+            context.tokens.next();
+            return parseGeneral(context, {
+                end: ['expression.end'],
+            });
+        default:
+            return { type: 'expr', line, values: [] };
+    }
+}

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

@@ -0,0 +1,51 @@
+import { simplifyNode } from '../nodeUtils.js';
+import { getValue } from './getValue.js';
+import { parseList } from './parseList.js';
+import { parseObject } from './parseObject.js';
+export function parseGeneral(context, options) {
+    const { tokens, ruleMap, withLabel, blocks } = context;
+    const { end, keepNested } = options;
+    const result = {
+        type: 'expr',
+        line: context.getCurrentLine(),
+        values: [],
+    };
+    let token;
+    while ((token = tokens.current())) {
+        const type = token.customType;
+        if (!token || (end && end.includes(token.customType))) {
+            break;
+        }
+        if (!type) {
+            result.values.push(getValue(context));
+            tokens.next();
+        }
+        else if (ruleMap.has(type)) {
+            result.values.push(withLabel(ruleMap.get(type))(context));
+            if (token === tokens.current()) {
+                throw new Error(`SYSTEM ERROR: Rule "${type}" didn't consume any tokens`);
+            }
+            // not loading new token when rule ended
+        }
+        else if (type === 'block.begin') {
+            result.values.push(withLabel(parseObject)(context));
+        }
+        else if (type === 'list.begin') {
+            result.values.push(withLabel(parseList)(context, 'list.end'));
+            // list consumes last token, so no loading next
+        }
+        else if (blocks[type]) {
+            withLabel(tokens.next)();
+            result.values.push(withLabel(parseGeneral)(context, {
+                end: blocks[type],
+                keepNested,
+            }));
+            withLabel(tokens.next)();
+        }
+        else {
+            result.values.push(getValue(context));
+            tokens.next();
+        }
+    }
+    return keepNested ? result : simplifyNode(result);
+}

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

@@ -0,0 +1,33 @@
+import { parseGeneral } from './parseGeneral.js';
+/*
+ * React.createElement(T, { keyName: 'key1' }, "default value")
+ *                     ^--------------------------------------^
+ *
+ * or
+ *
+ * ['item', 'item']
+ * ^--------------^
+ */
+export function parseList(context, end) {
+    const { tokens, getCurrentLine } = context;
+    const line = getCurrentLine();
+    tokens.next();
+    const result = [];
+    let token;
+    while ((token = tokens.current())) {
+        if (end && end === token.customType) {
+            tokens.next();
+            break;
+        }
+        switch (token.customType) {
+            case 'separator.comma':
+                tokens.next();
+                break;
+            default:
+                result.push(parseGeneral(context, {
+                    end: ['separator.comma', end],
+                }));
+        }
+    }
+    return { type: 'array', line, values: result };
+}

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

@@ -0,0 +1,130 @@
+import { extractString, isString } from '../nodeUtils.js';
+import { parseGeneral } from './parseGeneral.js';
+// { key: 'value', ... }
+// ^-------------------^
+export function parseObject(context) {
+    const { tokens, getCurrentLine } = context;
+    const line = getCurrentLine();
+    const result = { type: 'dict', line, value: {}, unknown: [] };
+    tokens.next();
+    let token;
+    let state = 0 /* S.ExpectProperty */;
+    let lastKey;
+    function fallbackToBlock() {
+        const combinedResult = {
+            type: 'expr',
+            line,
+            values: [...Object.values(result.value), ...result.unknown],
+        };
+        const parsedContent = parseGeneral(context, {
+            end: ['block.end'],
+        });
+        tokens.next();
+        if (parsedContent.type === 'expr') {
+            // avoid nesting
+            combinedResult.values.push(...parsedContent.values);
+        }
+        else {
+            combinedResult.values.push(parsedContent);
+        }
+        return combinedResult;
+    }
+    loop: while ((token = tokens.current())) {
+        const type = token.customType;
+        if (type === 'block.end') {
+            tokens.next();
+            break loop;
+        }
+        switch (state) {
+            case 0 /* S.ExpectProperty */:
+                if (type === 'object.key') {
+                    state = 1 /* S.ExpectDoubleColon */;
+                    lastKey = token.token;
+                }
+                else if (type === 'variable') {
+                    result.value[token.token] = {
+                        type: 'expr',
+                        line: getCurrentLine(),
+                        values: [],
+                    };
+                    state = 3 /* S.ExpectComma */;
+                }
+                else if (type === 'list.begin') {
+                    // dynamic key name '[value]: ...'
+                    tokens.next();
+                    const inside = parseGeneral(context, {
+                        end: ['list.end'],
+                    });
+                    if (isString(inside)) {
+                        lastKey = extractString(inside);
+                    }
+                    else {
+                        // dynamic keyname
+                        result.unknown.push(inside);
+                        lastKey = undefined;
+                    }
+                    state = 1 /* S.ExpectDoubleColon */;
+                }
+                else if (type === 'kw.async') {
+                    // there might be async function call,
+                    // we can just ignore this keyword
+                }
+                else if (type === 'function.call') {
+                    // shorthand for function definition, treat as dynamic value
+                    result.value[token.token] = parseGeneral(context, {
+                        end: ['separator.comma', 'block.end'],
+                    });
+                    state = 3 /* S.ExpectComma */;
+                    // don't load next token, it was loaded by extract
+                    continue;
+                }
+                else {
+                    // it's not object, but block
+                    // just somehow stich together already loaded values
+                    // and the rest
+                    return fallbackToBlock();
+                }
+                break;
+            case 1 /* S.ExpectDoubleColon */:
+                if (type === 'acessor.doublecolon') {
+                    state = 2 /* S.ExpectValue */;
+                }
+                else {
+                    // it's not object, but block
+                    // just somehow stich together already loaded values
+                    // and the rest
+                    return fallbackToBlock();
+                }
+                break;
+            case 2 /* S.ExpectValue */: {
+                const value = parseGeneral(context, {
+                    end: ['separator.comma', 'block.end'],
+                });
+                if (lastKey) {
+                    result.value[lastKey] = value;
+                }
+                else {
+                    // unknown key name
+                    result.unknown.push(value);
+                }
+                lastKey = undefined;
+                state = 3 /* S.ExpectComma */;
+                // don't load next token, it was loaded by extract
+                continue;
+            }
+            case 3 /* S.ExpectComma */:
+                if (type === 'separator.comma') {
+                    state = 0 /* S.ExpectProperty */;
+                }
+                else {
+                    // it's not object, but block
+                    // just somehow stich together already loaded values
+                    // and the rest
+                    return fallbackToBlock();
+                }
+                break;
+        }
+        tokens.next();
+    }
+    return result;
+}

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

@@ -0,0 +1,56 @@
+import { parseGeneral } from './parseGeneral.js';
+// <T keyName="key1" defaultValue="default value" />
+// ^^–––––––––––––––––––––––––––––^^^^^^^^^^^^^^^
+export function extractProps(context) {
+    function getShortHandValue() {
+        return { type: 'primitive', line: getCurrentLine(), value: true };
+    }
+    const { tokens, getCurrentLine } = context;
+    const line = getCurrentLine();
+    tokens.next();
+    const result = { type: 'dict', line, value: {}, unknown: [] };
+    let token;
+    let state = 0 /* S.ExpectAttribute */;
+    let lastKey;
+    while ((token = tokens.current())) {
+        const type = token.customType;
+        if (type === 'tag.self-closing.end' || type === 'tag.regular.end') {
+            break;
+        }
+        switch (state) {
+            case 0 /* S.ExpectAttribute */:
+                if (type === 'tag.attribute.name') {
+                    lastKey = token.token;
+                    state = 1 /* S.ExpectAssign */;
+                    // assign in case it's shorthand
+                    result.value[lastKey] = getShortHandValue();
+                }
+                break;
+            case 1 /* S.ExpectAssign */:
+                if (type === 'operator.assignment') {
+                    state = 2 /* S.ExpectValue */;
+                }
+                else if (type === 'tag.attribute.name') {
+                    // last one was shorthand
+                    lastKey = token.token;
+                    state = 1 /* S.ExpectAssign */;
+                    // assign in case it's shorthand
+                    result.value[lastKey] = getShortHandValue();
+                }
+                break;
+            case 2 /* S.ExpectValue */:
+                result.value[lastKey] = parseGeneral(context, {
+                    end: [
+                        'tag.attribute.name',
+                        'tag.self-closing.end',
+                        'tag.regular.end',
+                    ],
+                });
+                state = 0 /* S.ExpectAttribute */;
+                lastKey = undefined;
+                continue;
+        }
+        tokens.next();
+    }
+    return result;
+}

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

@@ -0,0 +1,26 @@
+import { isEmptyExpr, simplifyNode } from '../nodeUtils.js';
+import { parseGeneral } from './parseGeneral.js';
+import { extractProps } from './parseProps.js';
+// <T keyName="test">Default</T>
+// ^^-----------------------^^^^
+export const parseTag = (context) => {
+    const { tokens } = context;
+    const props = extractProps(context);
+    let child;
+    const currentTag = tokens.current();
+    if (currentTag?.customType === 'tag.regular.end') {
+        tokens.next();
+        // it's not self-closing and there are children
+        const extracted = parseGeneral(context, {
+            end: ['tag.closing'],
+            // don't simplify here, to see, if there are any children
+            keepNested: true,
+        });
+        if (!isEmptyExpr(extracted)) {
+            // there are some children
+            child = simplifyNode(extracted);
+        }
+    }
+    tokens.next();
+    return { props, child };
+};

package/dist/extractor/parser/types.js

@@ -0,0 +1 @@
+export {};

package/dist/extractor/parserReact/ParserReact.js

@@ -0,0 +1,30 @@
+import { pipeMachines } from '../parser/mergerMachine.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { generalMapper } from '../parser/generalMapper.js';
+import { reactMapper } from './jsxMapper.js';
+import { createElementMerger } from './tokenMergers/createElementMerger.js';
+import { tComponentMerger } from './tokenMergers/tComponentMerger.js';
+import { tFunctionMerger } from './tokenMergers/tFunctionMerger.js';
+import { useTranslateMerger } from './tokenMergers/useTranslateMerger.js';
+import { reactCreateElement } from './rules/createElement.js';
+import { tComponent } from './rules/tComponent.js';
+import { tFunction } from './rules/tFunction.js';
+import { useTranslate } from './rules/useTranslate.js';
+const reactMappers = [generalMapper, reactMapper];
+export const reactMergers = pipeMachines([
+    ...DEFAULT_MERGERERS,
+    createElementMerger,
+    useTranslateMerger,
+    tFunctionMerger,
+    tComponentMerger,
+]);
+export const ParserReact = () => {
+    return Parser({
+        mappers: [generalMapper, reactMapper],
+        blocks: {
+            ...DEFAULT_BLOCKS,
+        },
+        rules: [reactCreateElement, tComponent, tFunction, useTranslate],
+        merger: reactMergers,
+    });
+};

package/dist/extractor/parserReact/jsxMapper.js

@@ -0,0 +1,24 @@
+export const reactMapper = (token) => {
+    switch (token.type) {
+        // JSX string children
+        case 'meta.jsx.children.tsx':
+            return 'string.template';
+        // template strings - treating as expression
+        case 'punctuation.definition.template-expression.begin.ts':
+        case 'punctuation.section.embedded.begin.tsx':
+            return 'expression.template.begin';
+        case 'punctuation.definition.template-expression.end.ts':
+        case 'punctuation.section.embedded.end.tsx':
+            return 'expression.template.end';
+        // react tags
+        case 'punctuation.definition.tag.begin.tsx':
+            return token.token === '</' ? 'tag.closing.begin' : 'tag.regular.begin';
+        case 'punctuation.definition.tag.end.tsx':
+            return token.token === '/>' ? 'tag.self-closing.end' : 'tag.regular.end';
+        case 'support.class.component.tsx':
+        case 'entity.name.tag.tsx':
+            return 'tag.name';
+        case 'entity.other.attribute-name.tsx':
+            return 'tag.attribute.name';
+    }
+};

package/dist/extractor/parserReact/rules/createElement.js

@@ -0,0 +1,62 @@
+import { parseList } from '../../parser/tree/parseList.js';
+// React.createElement(T, { keyName: 'key1' }, "default value")
+// ^^^^^^^^^^^^^^^^^^^^^--------------------------------------^
+export const reactCreateElement = {
+    trigger: 'trigger.react.create.t.element',
+    call(context) {
+        const line = context.getCurrentLine();
+        const args = parseList(context, 'expression.end');
+        if (args.type !== 'array') {
+            // invalid arguments
+            return args;
+        }
+        const result = {
+            type: 'keyInfo',
+            line,
+            dependsOnContext: false,
+            values: [],
+        };
+        const [props, ...children] = args.values;
+        // read props
+        if (props.type === 'dict') {
+            for (const [key, value] of Object.entries(props.value)) {
+                switch (key) {
+                    case 'keyName':
+                        result.keyName = value;
+                        break;
+                    case 'defaultValue':
+                        result.defaultValue = value;
+                        break;
+                    case 'ns':
+                        result.namespace = value;
+                        break;
+                    default:
+                        // unknown parameter
+                        result.values.push(value);
+                }
+            }
+        }
+        let child;
+        // if there is multiple children, wrap them in array
+        if (children.length === 1) {
+            child = children[0];
+        }
+        else if (children.length > 1) {
+            child = { type: 'array', line: children[0].line, values: children };
+        }
+        // read children
+        if (child) {
+            if (!result.keyName) {
+                result.keyName = child;
+            }
+            else if (!result.defaultValue) {
+                result.defaultValue = child;
+            }
+            else {
+                // child has no semantic meaning
+                result.values.push(child);
+            }
+        }
+        return result;
+    },
+};

package/dist/extractor/parserReact/rules/tComponent.js

@@ -0,0 +1,9 @@
+import { tComponentGeneral } from '../../parser/rules/tComponentGeneral.js';
+// <T keyName="test">Default</T>
+// ^^-----------------------^^^^
+export const tComponent = {
+    trigger: 'trigger.t.component',
+    call(context) {
+        return tComponentGeneral(context);
+    },
+};

package/dist/extractor/parserReact/rules/tFunction.js

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

package/dist/extractor/parserReact/rules/useTranslate.js

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

package/dist/extractor/parserReact/tokenMergers/createElementMerger.js

@@ -0,0 +1,35 @@
+// React.createElement(T,
+export const createElementMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        const token = t.token;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'variable' && token === 'React') {
+                    return 1 /* S.ExpectDot */;
+                }
+                break;
+            case 1 /* S.ExpectDot */:
+                if (type === 'acessor.dot') {
+                    return 2 /* S.ExpectCall */;
+                }
+                break;
+            case 2 /* S.ExpectCall */:
+                if (type === 'function.call') {
+                    return 3 /* S.ExpectBracket */;
+                }
+                break;
+            case 3 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return 4 /* S.ExpectT */;
+                }
+                break;
+            case 4 /* S.ExpectT */:
+                if (type === 'variable' && token === 'T') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.react.create.t.element',
+};

package/dist/extractor/parserReact/tokenMergers/tComponentMerger.js

@@ -0,0 +1,20 @@
+// <T
+export const tComponentMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        const token = t.token;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'tag.regular.begin') {
+                    return 1 /* S.ExpectT */;
+                }
+                break;
+            case 1 /* S.ExpectT */:
+                if (type === 'tag.name' && token === 'T') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.t.component',
+};

package/dist/extractor/parserReact/tokenMergers/tFunctionMerger.js

@@ -0,0 +1,23 @@
+// t(
+export const tFunctionMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        const token = t.token;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'function.call' && token === 't') {
+                    return 1 /* S.ExpectBracket */;
+                }
+                else if (type === 'acessor.dot') {
+                    return 2 /* S.Ignore */;
+                }
+                break;
+            case 1 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.t.function',
+};

package/dist/extractor/parserReact/tokenMergers/useTranslateMerger.js

@@ -0,0 +1,20 @@
+// useTranslate(
+export const useTranslateMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        const token = t.token;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'function.call' && token === 'useTranslate') {
+                    return 1 /* S.ExpectBracket */;
+                }
+                break;
+            case 1 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.use.translate',
+};

package/dist/extractor/parserSvelte/ParserSvelte.js

@@ -0,0 +1,32 @@
+import { pipeMachines } from '../parser/mergerMachine.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { svelteMapper } from './svelteMapper.js';
+import { generalMapper } from '../parser/generalMapper.js';
+import { tFunctionMerger } from './tokenMergers/tFunctionMerger.js';
+import { getTranslateMerger } from './tokenMergers/getTranslateMerger.js';
+import { scriptTagMerger } from './tokenMergers/scriptTagMerger.js';
+import { tComponentMerger } from './tokenMergers/tComponentMerger.js';
+import { tFunction } from './rules/tFunction.js';
+import { getTranslate } from './rules/useTranslate.js';
+import { tComponent } from './rules/tComponent.js';
+import { scriptTag } from './rules/scriptTag.js';
+import { svelteTreeTransform } from './svelteTreeTransform.js';
+const svelteMappers = [generalMapper, svelteMapper];
+export const svelteMergers = pipeMachines([
+    ...DEFAULT_MERGERERS,
+    tFunctionMerger,
+    getTranslateMerger,
+    tComponentMerger,
+    scriptTagMerger,
+]);
+export const ParserSvelte = () => {
+    return Parser({
+        mappers: svelteMappers,
+        blocks: {
+            ...DEFAULT_BLOCKS,
+        },
+        rules: [tFunction, getTranslate, tComponent, scriptTag],
+        treeTransform: svelteTreeTransform,
+        merger: svelteMergers,
+    });
+};

package/dist/extractor/parserSvelte/contextConstants.js

@@ -0,0 +1 @@
+export const SVELTE_SCRIPT = 'script';

package/dist/extractor/parserSvelte/rules/scriptTag.js

@@ -0,0 +1,26 @@
+import { parseTag } from '../../parser/tree/parseTag.js';
+import { SVELTE_SCRIPT } from '../contextConstants.js';
+// <script ...>....</script>
+// ^^^^^^^-----------^^^^^^^^^
+export const scriptTag = {
+    trigger: 'trigger.script.tag',
+    call(context) {
+        const line = context.getCurrentLine();
+        const { props, child } = parseTag(context);
+        const result = {
+            type: 'expr',
+            line,
+            values: [props],
+        };
+        if (child) {
+            if (child.type === 'expr') {
+                result.values.push(...child.values);
+            }
+            else {
+                result.values.push(child);
+            }
+        }
+        result.context = SVELTE_SCRIPT;
+        return result;
+    },
+};

package/dist/extractor/parserSvelte/rules/tComponent.js

@@ -0,0 +1,9 @@
+import { tComponentGeneral } from '../../parser/rules/tComponentGeneral.js';
+// <T keyName="test">Default</T>
+// ^^-----------------------^^^^
+export const tComponent = {
+    trigger: 'trigger.t.component',
+    call(context) {
+        return tComponentGeneral(context);
+    },
+};

package/dist/extractor/parserSvelte/rules/tFunction.js

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

package/dist/extractor/parserSvelte/rules/useTranslate.js

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