@tolgee/cli 2.0.4 → 2.1.0

package/dist/extractor/parserSvelte/svelteMapper.js

@@ -0,0 +1,39 @@
+export const svelteMapper = (token) => {
+    switch (token.type) {
+        // strings
+        case 'punctuation.definition.string.begin.svelte':
+            return 'string.begin';
+        case 'punctuation.definition.string.end.svelte':
+            return 'string.end';
+        case 'string.quoted.svelte':
+            return 'string.body';
+        case 'string.unquoted.svelte':
+            return 'string';
+        // svelte template expression
+        case 'punctuation.section.embedded.begin.svelte':
+            return 'expression.template.begin';
+        case 'punctuation.section.embedded.end.svelte':
+            return 'expression.template.end';
+        //
+        case 'punctuation.definition.variable.svelte':
+            return 'store.accessor.svelte';
+        // svelte template
+        // tags
+        case 'punctuation.definition.tag.begin.svelte':
+            return token.token === '</' ? 'tag.closing.begin' : 'tag.regular.begin';
+        case 'punctuation.definition.tag.end.svelte':
+            return token.token === '/>' ? 'tag.self-closing.end' : 'tag.regular.end';
+        case 'support.class.component.svelte':
+        case 'entity.name.tag.svelte':
+            return 'tag.name';
+        case 'entity.other.attribute-name.svelte':
+            return 'tag.attribute.name';
+        case 'punctuation.separator.key-value.svelte':
+            return 'operator.assignment';
+        // html comments
+        case 'punctuation.definition.comment.svelte':
+            return 'comment.definition';
+        case 'comment.block.svelte':
+            return 'comment.block';
+    }
+};

package/dist/extractor/parserSvelte/svelteTreeTransform.js

@@ -0,0 +1,38 @@
+import { SVELTE_SCRIPT } from './contextConstants.js';
+/**
+ * Putting scripts to the top
+ *
+ * ```
+ * <div>{$t('key1')}</div>
+ * <script>
+ *  const {t} = getTranslate('namespace')
+ * </script>
+ * ```
+ *
+ * transforming essentially to this:
+ *
+ * ```
+ * const {t} = getTranslate('namespace')
+ *
+ * <div>{$t('key1')}</div>
+ * ```
+ */
+export const svelteTreeTransform = (root) => {
+    if (root.type !== 'expr') {
+        return { tree: root };
+    }
+    const scripts = [];
+    const other = [];
+    for (const node of root.values) {
+        if (node.type === 'expr' && node.context === SVELTE_SCRIPT) {
+            scripts.push(...node.values);
+        }
+        else {
+            other.push(node);
+        }
+    }
+    // put scripts to top
+    // and other to bottom
+    root.values = [...scripts, ...other];
+    return { tree: root };
+};

package/dist/extractor/parserSvelte/tokenMergers/getTranslateMerger.js

@@ -0,0 +1,20 @@
+// getTranslate(
+export const getTranslateMerger = {
+    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 === 'getTranslate') {
+                    return 1 /* S.ExpectBracket */;
+                }
+                break;
+            case 1 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.get.translate',
+};

package/dist/extractor/parserSvelte/tokenMergers/scriptTagMerger.js

@@ -0,0 +1,20 @@
+// <script
+export const scriptTagMerger = {
+    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.ExpectTemplate */;
+                }
+                break;
+            case 1 /* S.ExpectTemplate */:
+                if (type === 'tag.name' && token === 'script') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.script.tag',
+};

package/dist/extractor/parserSvelte/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/parserSvelte/tokenMergers/tFunctionMerger.js

@@ -0,0 +1,29 @@
+// 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 === 'store.accessor.svelte' && token === '$') {
+                    return 1 /* S.ExpectT */;
+                }
+                else if (type === 'acessor.dot') {
+                    return 3 /* S.Ignore */;
+                }
+                break;
+            case 1 /* S.ExpectT */:
+                if (type === 'function.call' && token === 't') {
+                    return 2 /* S.ExpectBracket */;
+                }
+                break;
+            case 2 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_ALL;
+                }
+                break;
+        }
+    },
+    customType: 'trigger.t.function',
+};

package/dist/extractor/parserVue/ParserVue.js

@@ -0,0 +1,45 @@
+import { pipeMachines } from '../parser/mergerMachine.js';
+import { DEFAULT_BLOCKS, DEFAULT_MERGERERS, Parser } from '../parser/parser.js';
+import { generalMapper } from '../parser/generalMapper.js';
+import { vueMapper } from './vueMapper.js';
+import { vueTreeTransform } from './vueTreeTransform.js';
+import { globalTFunctionMerger } from './tokenMergers/globalTFunctionMerger.js';
+import { tFunctionMerger } from './tokenMergers/tFunctionMerger.js';
+import { useTranslateMerger } from './tokenMergers/useTranslateMerger.js';
+import { exportDefaultObjectMerger } from './tokenMergers/exportDefaultObjectMerger.js';
+import { scriptTagMerger } from './tokenMergers/scriptTagMerger.js';
+import { tComponentMerger } from './tokenMergers/tComponentMerger.js';
+import { globalTFunction } from './rules/globalTFunction.js';
+import { tFunction } from './rules/tFunction.js';
+import { useTranslate } from './rules/useTranslate.js';
+import { tComponent } from './rules/tComponent.js';
+import { scriptTag } from './rules/scriptTag.js';
+import { exportDefaultObject } from './rules/exportDefaultObject.js';
+const vueMappers = [generalMapper, vueMapper];
+export const vueMergers = pipeMachines([
+    ...DEFAULT_MERGERERS,
+    globalTFunctionMerger,
+    tFunctionMerger,
+    useTranslateMerger,
+    tComponentMerger,
+    scriptTagMerger,
+    exportDefaultObjectMerger,
+]);
+export const ParserVue = () => {
+    return Parser({
+        mappers: vueMappers,
+        blocks: {
+            ...DEFAULT_BLOCKS,
+        },
+        rules: [
+            globalTFunction,
+            tFunction,
+            useTranslate,
+            tComponent,
+            scriptTag,
+            exportDefaultObject,
+        ],
+        merger: vueMergers,
+        treeTransform: vueTreeTransform,
+    });
+};

package/dist/extractor/parserVue/contextConstants.js

@@ -0,0 +1,3 @@
+export const VUE_SCRIPT_REGULAR = 'script.regular';
+export const VUE_SCRIPT_SETUP = 'script.setup';
+export const VUE_COMPONENT_CONFIG = 'vue.component.config';

package/dist/extractor/parserVue/rules/exportDefaultObject.js

@@ -0,0 +1,14 @@
+import { parseObject } from '../../parser/tree/parseObject.js';
+import { VUE_COMPONENT_CONFIG } from '../contextConstants.js';
+// export default { setup() { .... } }
+// ^^^^^^^^^^^^^^^^------------------^
+export const exportDefaultObject = {
+    trigger: 'trigger.export.default.object',
+    call(context) {
+        const result = parseObject(context);
+        if (result.type === 'dict' && result.value['setup']) {
+            result.context = VUE_COMPONENT_CONFIG;
+        }
+        return result;
+    },
+};

package/dist/extractor/parserVue/rules/globalTFunction.js

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

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

@@ -0,0 +1,31 @@
+import { parseTag } from '../../parser/tree/parseTag.js';
+import { VUE_SCRIPT_REGULAR, VUE_SCRIPT_SETUP } from '../contextConstants.js';
+// <script setup>....</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);
+            }
+        }
+        if (props.type === 'dict' && Boolean(props.value['setup'])) {
+            result.context = VUE_SCRIPT_SETUP;
+        }
+        else {
+            result.context = VUE_SCRIPT_REGULAR;
+        }
+        return result;
+    },
+};

package/dist/extractor/parserVue/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/parserVue/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/parserVue/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/parserVue/tokenMergers/exportDefaultObjectMerger.js

@@ -0,0 +1,25 @@
+// export default {
+export const exportDefaultObjectMerger = {
+    initial: 0 /* S.Idle */,
+    step: (state, t, end) => {
+        const type = t.customType;
+        switch (state) {
+            case 0 /* S.Idle */:
+                if (type === 'keyword.export') {
+                    return 1 /* S.ExpectDefault */;
+                }
+                break;
+            case 1 /* S.ExpectDefault */:
+                if (type === 'keyword.default') {
+                    return 2 /* S.ExpectBlockStart */;
+                }
+                break;
+            case 2 /* S.ExpectBlockStart */:
+                if (type === 'block.begin') {
+                    return end.MERGE_ALL;
+                }
+                break;
+        }
+    },
+    customType: 'trigger.export.default.object',
+};

package/dist/extractor/parserVue/tokenMergers/globalTFunctionMerger.js

@@ -0,0 +1,36 @@
+// $t(
+export const globalTFunctionMerger = {
+    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 === 'variable' && token === 'this') {
+                    return 2 /* S.ExpectDot */;
+                }
+                else if (type === 'acessor.dot') {
+                    return 4 /* S.Ignore */;
+                }
+                break;
+            case 2 /* S.ExpectDot */:
+                if (type === 'acessor.dot') {
+                    return 3 /* S.ExpectCall */;
+                }
+                break;
+            case 3 /* S.ExpectCall */:
+                if (type === 'function.call' && token === '$t') {
+                    return 1 /* S.ExpectBracket */;
+                }
+                break;
+            case 1 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.global.t.function',
+};

package/dist/extractor/parserVue/tokenMergers/scriptTagMerger.js

@@ -0,0 +1,20 @@
+// <script
+export const scriptTagMerger = {
+    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.ExpectTemplate */;
+                }
+                break;
+            case 1 /* S.ExpectTemplate */:
+                if (type === 'tag.name' && token === 'script') {
+                    return end.MERGE_ALL;
+                }
+        }
+    },
+    customType: 'trigger.script.tag',
+};

package/dist/extractor/parserVue/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/parserVue/tokenMergers/tFunctionMerger.js

@@ -0,0 +1,37 @@
+// 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 3 /* S.ExpectBracket */;
+                }
+                else if (type === 'variable' && token === 't') {
+                    return 1 /* S.ExpectDot */;
+                }
+                else if (type === 'acessor.dot') {
+                    return 4 /* S.Ignore */;
+                }
+                break;
+            case 3 /* S.ExpectBracket */:
+                if (type === 'expression.begin') {
+                    return end.MERGE_ALL;
+                }
+                break;
+            case 1 /* S.ExpectDot */:
+                if (type === 'acessor.dot') {
+                    return 2 /* S.ExpectValueMethod */;
+                }
+                break;
+            case 2 /* S.ExpectValueMethod */:
+                if (type === 'function.call') {
+                    return 3 /* S.ExpectBracket */;
+                }
+                break;
+        }
+    },
+    customType: 'trigger.t.function',
+};

package/dist/extractor/parserVue/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/parserVue/vueMapper.js

@@ -0,0 +1,51 @@
+export const vueMapper = (token) => {
+    const type = token.type;
+    switch (token.type) {
+        // vue template expression
+        case 'punctuation.definition.string.begin.html.vue':
+            return 'expression.template.begin';
+        case 'punctuation.definition.string.end.html.vue':
+            return 'expression.template.end';
+        // vue template tags
+        case 'punctuation.definition.tag.begin.html':
+        case 'punctuation.definition.tag.begin.html.vue':
+            return token.token === '</' ? 'tag.closing.begin' : 'tag.regular.begin';
+        case 'punctuation.definition.tag.end.html.vue':
+        case 'punctuation.definition.tag.end.html':
+            return token.token === '/>' ? 'tag.self-closing.end' : 'tag.regular.end';
+        case type.match(/^entity\.name\.tag\.[^.]+\.html\.vue$/) ? type : false:
+        case 'entity.name.tag.html':
+            return 'tag.name';
+        case 'entity.other.attribute-name.html.vue':
+        case 'entity.other.attribute-name.html':
+            return 'tag.attribute.name';
+        case 'punctuation.separator.key-value.html':
+        case 'punctuation.separator.key-value.html.vue':
+            return 'operator.assignment';
+        // html string attributes
+        case 'punctuation.definition.string.begin.html':
+            return 'string.begin';
+        case 'punctuation.definition.string.end.html':
+            return 'string.end';
+        case 'string.quoted.single.html':
+        case 'string.quoted.double.html':
+            return 'string.body';
+        case 'string.unquoted.html':
+            return 'string';
+        // html comments
+        case 'punctuation.definition.comment.html':
+            return 'comment.definition';
+        case 'comment.block.html':
+            return 'comment.block';
+        // ignore template modifiers
+        // we only basically care about the content
+        case 'punctuation.attribute-shorthand.event.html.vue':
+        case 'punctuation.attribute-shorthand.bind.html.vue':
+            return 'ignore';
+        // `export default` is needed to track down setup function
+        case 'keyword.control.export.ts':
+            return 'keyword.export';
+        case 'keyword.control.default.ts':
+            return 'keyword.default';
+    }
+};

package/dist/extractor/parserVue/vueTreeTransform.js

@@ -0,0 +1,109 @@
+import { VUE_SCRIPT_REGULAR, VUE_SCRIPT_SETUP, VUE_COMPONENT_CONFIG, } from './contextConstants.js';
+/*
+ * We get this
+ *
+ * `(item) {item, item}`
+ *
+ * so we put the expression insides one level up (never mind the arguments):
+ *
+ * `item, item, item`
+ */
+function flattenOneLevel(nodes) {
+    const result = [];
+    nodes.forEach((node) => {
+        if (node.type === 'expr') {
+            result.push(...node.values);
+        }
+        else {
+            result.push(node);
+        }
+    });
+    return result;
+}
+/*
+ * We get structure like this
+ * {
+ *   setup(item) {
+ *      item, item
+ *   }
+ * }
+ * and setup content should be on top level
+ */
+function bringSetupToTopLevel(context, node) {
+    const setupContent = [];
+    for (const item of node.values) {
+        if (item.type === 'dict' && item.context === VUE_COMPONENT_CONFIG) {
+            const { setup, ...rest } = item.value;
+            if (setup.type === 'expr') {
+                if (setup.values.length === 0) {
+                    context.warnings.push({
+                        line: setup.line,
+                        warning: 'W_VUE_SETUP_IS_A_REFERENCE',
+                    });
+                }
+                setupContent.push(...flattenOneLevel(setup.values));
+                item.value = { ...rest };
+            }
+        }
+    }
+    return [node, ...setupContent];
+}
+/**
+ * Putting scripts to the top and extracting setup function, so:
+ *
+ * ```
+ * <template>
+ *  <div>{t('key1')}</div>
+ * <template>
+ * <script>
+ * export default {
+ *   setup() {
+ *     const {t} = useTranslate('namespace')
+ *   },
+ *   ...
+ * }
+ * </script>
+ * ```
+ *
+ * transforming essentially to this:
+ *
+ * ```
+ * export default {
+ *   ...
+ * }
+ * const {t} = useTranslate('namespace')
+ * <template>
+ *  <div>{{ t('key1') }}</div>
+ * <template>
+ * ```
+ */
+export const vueTreeTransform = (root) => {
+    if (root.type !== 'expr') {
+        return { tree: root };
+    }
+    const context = {
+        keys: [],
+        warnings: [],
+    };
+    const scripts = [];
+    const other = [];
+    for (const node of root.values) {
+        if (node.type === 'expr' &&
+            (node.context === VUE_SCRIPT_REGULAR || node.context === VUE_SCRIPT_SETUP)) {
+            if (node.context === VUE_SCRIPT_REGULAR) {
+                // we need to dig deeper for the `setup` function
+                scripts.push(...bringSetupToTopLevel(context, node));
+            }
+            else {
+                scripts.push(...node.values);
+            }
+        }
+        else {
+            other.push(node);
+        }
+    }
+    // put scripts to top
+    // and other to bottom
+    root.values = [...scripts, ...other];
+    return { tree: root, report: context };
+};