@intlify/vue-i18n-extensions 6.0.2 → 6.0.4

package/dist/cjs/builder.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContentBuilder = void 0;
+const shared_1 = require("@intlify/shared");
+/**
+ * Create a Content Builder
+ *
+ * @param options - Content Builder options
+ *
+ * @returns A {@link ContentBuilder} instance
+ *
+ * @public
+ */
+function createContentBuilder(options = {}) {
+    let _indentLevel = options.indentLevel != null && (0, shared_1.isNumber)(options.indentLevel) ? options.indentLevel : 0;
+    let _content = '';
+    function push(content) {
+        _content += content;
+    }
+    function _newline(n) {
+        push('\n' + `  `.repeat(n));
+    }
+    function newline() {
+        _newline(_indentLevel);
+    }
+    function pushline(content) {
+        push(content);
+        newline();
+    }
+    function indent(withoutNewLine) {
+        if (withoutNewLine) {
+            ++_indentLevel;
+        }
+        else {
+            _newline(++_indentLevel);
+        }
+    }
+    function deindent(withoutNewLine) {
+        if (withoutNewLine) {
+            --_indentLevel;
+        }
+        else {
+            _newline(--_indentLevel);
+        }
+    }
+    return {
+        get indentLevel() {
+            return _indentLevel;
+        },
+        get content() {
+            return String(_content);
+        },
+        push,
+        newline,
+        pushline,
+        indent,
+        deindent
+    };
+}
+exports.createContentBuilder = createContentBuilder;

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVTDirective = void 0;
+var transform_1 = require("./transform");
+Object.defineProperty(exports, "transformVTDirective", { enumerable: true, get: function () { return transform_1.transformVTDirective; } });

package/dist/cjs/report.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.report = exports.getReportMessage = void 0;
+const shared_1 = require("@intlify/shared");
+// TODO: should be extracted as i18n resources (intlify project self hosting!)
+const ReportMessages = {
+    [1 /* ReportCodes.UNEXPECTED_DIRECTIVE_EXPRESSION */]: `Unexpected directive expression: {0}`,
+    [2 /* ReportCodes.NOT_SUPPORTED */]: `Not supported transform: {0}`,
+    [3 /* ReportCodes.FAILED_VALUE_EVALUATION */]: `Failed value evaluation: {0}`,
+    [4 /* ReportCodes.REQUIRED_PARAMETER */]: `Required parameter: {0}`,
+    [5 /* ReportCodes.INVALID_PARAMETER_TYPE */]: `Required parameter: {0}`,
+    [6 /* ReportCodes.OVERRIDE_ELEMENT_CHILDREN */]: `v-t will override element children: {0}`,
+    [7 /* ReportCodes.NOT_RESOLVED_COMPOSER */]: `Not resolved vue-i18n composer: {0}`,
+    [8 /* ReportCodes.UNEXPECTED_ERROR */]: `Unexpected error: {0}`
+};
+function getReportMessage(code, ...args) {
+    return (0, shared_1.format)(ReportMessages[code], ...args);
+}
+exports.getReportMessage = getReportMessage;
+function createExtensionsError(code, msg, loc) {
+    const error = new SyntaxError(msg);
+    error.code = code;
+    if (loc) {
+        error.loc = loc;
+    }
+    return error;
+}
+function report(code, options = {}) {
+    const mode = options.mode && (0, shared_1.isString)(options.mode) && ['warn', 'error'].includes(options.mode)
+        ? options.mode
+        : 'warn';
+    const msg = getReportMessage(code, options.args);
+    if (mode === 'warn') {
+        console.warn('[vue-i18n-extensions] ' + msg);
+    }
+    else {
+        // error
+        throw createExtensionsError(code, msg, options.loc);
+    }
+}
+exports.report = report;

package/dist/cjs/transform.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVTDirective = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const shared_1 = require("@intlify/shared");
+const transpiler_1 = require("./transpiler");
+const report_1 = require("./report");
+const builder_1 = require("./builder");
+/**
+ * Transform `v-t` custom directive
+ *
+ * @remarks
+ * Transform that  `v-t` custom directive is optimized vue-i18n code by Vue compiler.
+ * This transform can improve the performance by pre-translating, and it does support SSR.
+ *
+ * @param options - `v-t` custom directive transform options, see {@link TransformVTDirectiveOptions}
+ * @returns Directive transform
+ *
+ * @example
+ * ```js
+ * import { compile } from '@vue/compiler-dom'
+ * import { createI18n } from 'vue-i18n'
+ * import { transformVTDirective } from '@intlify/vue-i18n-extensions'
+ *
+ * // create i18n instance
+ * const i18n = createI18n({
+ *   locale: 'ja',
+ *   messages: {
+ *     en: {
+ *       hello: 'hello'
+ *     },
+ *     ja: {
+ *       hello: 'こんにちは'
+ *     }
+ *   }
+ * })
+ *
+ * // get transform from  `transformVTDirective` function, with `i18n` option
+ * const transformVT = transformVTDirective({ i18n })
+ *
+ * const { code } = compile(`<p v-t="'hello'"></p>`, {
+ *   mode: 'function',
+ *   hoistStatic: true,
+ *   prefixIdentifiers: true,
+ *   directiveTransforms: { t: transformVT } // <- you need to specify to `directiveTransforms` option!
+ * })
+ *
+ * console.log(code)
+ * // output ->
+ * //   const { createVNode: _createVNode, openBlock: _openBlock, createBlock: _createBlock } = Vue
+ * //   return function render(_ctx, _cache) {
+ * //     return (_openBlock(), _createBlock(\\"div\\", null, \\"こんにちは！\\"))
+ * //   }
+ * ```
+ * @public
+ */
+function transformVTDirective(options = {}) {
+    const i18nInstance = options.i18n;
+    const mode = (0, shared_1.isString)(options.mode) && ['composition', 'legacy'].includes(options.mode)
+        ? options.mode
+        : 'composition';
+    // prettier-ignore
+    const translationSignatures = (0, shared_1.isString)(options.translationSignatures)
+        ? [options.translationSignatures]
+        : (0, shared_1.isArray)(options.translationSignatures)
+            ? options.translationSignatures
+            : ['t'];
+    translationSignatures.push(`$t`); // fallback to global scope
+    return (dir, node, context) => {
+        const { exp, loc } = dir;
+        // console.log('v-t dir', dir)
+        // console.log('v-t node', node)
+        if (!exp) {
+            // TODO: throw error with context.OnError
+            // NOTE: We need to support from @vue/compiler-core
+            // https://github.com/vuejs/vue-next/issues/1147
+            (0, report_1.report)(1 /* ReportCodes.UNEXPECTED_DIRECTIVE_EXPRESSION */, {
+                mode: 'error',
+                args: [node.loc.source || ''],
+                loc: node.loc
+            });
+        }
+        if (node.children.length > 0) {
+            // TODO: throw error with context.OnError
+            // NOTE: We need to support from @vue/compiler-core
+            // https://github.com/vuejs/vue-next/issues/1147
+            (0, report_1.report)(6 /* ReportCodes.OVERRIDE_ELEMENT_CHILDREN */, {
+                mode: 'error',
+                args: [node.loc.source || ''],
+                loc: node.loc
+            });
+            node.children.length = 0;
+        }
+        if (isSimpleExpressionNode(exp)) {
+            if (isConstant(exp) && i18nInstance) {
+                const { status, value } = (0, transpiler_1.evaluateValue)(exp.content);
+                if (status === 'ng') {
+                    (0, report_1.report)(3 /* ReportCodes.FAILED_VALUE_EVALUATION */, {
+                        args: [node.loc.source || ''],
+                        loc: node.loc
+                    });
+                    return { props: [] };
+                }
+                const [parsedValue, parseStatus] = parseValue(value);
+                if (parseStatus !== 0 /* ReportCodes.SUCCESS */) {
+                    (0, report_1.report)(parseStatus, { args: [node.loc.source || ''], loc: node.loc });
+                    return { props: [] };
+                }
+                if (parsedValue == null) {
+                    (0, report_1.report)(8 /* ReportCodes.UNEXPECTED_ERROR */, {
+                        args: [node.loc.source || ''],
+                        loc: node.loc
+                    });
+                    return { props: [] };
+                }
+                const global = getComposer(i18nInstance);
+                if (global == null) {
+                    (0, report_1.report)(7 /* ReportCodes.NOT_RESOLVED_COMPOSER */, {
+                        args: [node.loc.source || ''],
+                        loc: node.loc
+                    });
+                    return { props: [] };
+                }
+                const content = global.t(...makeParams(parsedValue));
+                node.children.push({
+                    type: compiler_dom_1.NodeTypes.TEXT,
+                    content
+                });
+                return { props: [] };
+            }
+            else {
+                const translationParams = (0, transpiler_1.parseVTExpression)(exp.content);
+                const code = generateTranslationCode(context, mode, translationParams, translationSignatures);
+                context.helper(compiler_dom_1.TO_DISPLAY_STRING);
+                node.children.push({
+                    type: compiler_dom_1.NodeTypes.INTERPOLATION,
+                    content: (0, compiler_dom_1.createCompoundExpression)([
+                        (0, compiler_dom_1.createSimpleExpression)(code, false, loc, 0 /* ConstantTypes.NOT_CONSTANT */)
+                    ])
+                });
+                return { props: [] };
+            }
+        }
+        else if (isCompoundExpressionNode(exp)) {
+            const content = exp.children.map(mapNodeContentHandler).join('');
+            const code = generateTranslationCode(context, mode, (0, transpiler_1.parseVTExpression)(content), translationSignatures);
+            context.helper(compiler_dom_1.TO_DISPLAY_STRING);
+            node.children.push({
+                type: compiler_dom_1.NodeTypes.INTERPOLATION,
+                content: (0, compiler_dom_1.createCompoundExpression)([
+                    (0, compiler_dom_1.createSimpleExpression)(code, false, loc, 0 /* ConstantTypes.NOT_CONSTANT */)
+                ])
+            });
+            return { props: [] };
+        }
+        else {
+            (0, report_1.report)(2 /* ReportCodes.NOT_SUPPORTED */, {
+                args: [node.loc.source || ''],
+                loc: node.loc
+            });
+            return { props: [] };
+        }
+    };
+}
+exports.transformVTDirective = transformVTDirective;
+function getComposer(i18n) {
+    return isI18nInstance(i18n) ? getComposerInternal(i18n) : null;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isI18nInstance(i18n) {
+    return i18n != null && 'global' in i18n && 'mode' in i18n;
+}
+function getComposerInternal(i18n) {
+    if (i18n.mode === 'composition') {
+        return isComposer(i18n.global) ? i18n.global : null;
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        return isVueI18n(i18n.global) ? i18n.global.__composer : null;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isComposer(target) {
+    return target != null && !('__composer' in target);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isVueI18n(target) {
+    return target != null && '__composer' in target;
+}
+function isSimpleExpressionNode(node) {
+    return node != null && node.type === compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION;
+}
+function isCompoundExpressionNode(node) {
+    return node != null && node.type === compiler_dom_1.NodeTypes.COMPOUND_EXPRESSION;
+}
+function isConstant(node) {
+    if ('isConstant' in node) {
+        // for v3.0.3 earlier
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        return node.isConstant;
+    }
+    else if ('constType' in node) {
+        // for v3.0.3 or later
+        return node.constType <= 3 /* ConstantTypes.CAN_STRINGIFY */;
+    }
+    else {
+        throw Error('unexpected error in Vue SimpleExpressionNode');
+    }
+}
+function mapNodeContentHandler(value) {
+    if ((0, shared_1.isString)(value)) {
+        return value;
+    }
+    else if ((0, shared_1.isSymbol)(value)) {
+        return value.description || '';
+    }
+    else if (isSimpleExpressionNode(value)) {
+        return value.content;
+    }
+    else if (isCompoundExpressionNode(value)) {
+        return value.children.map(mapNodeContentHandler).join('');
+    }
+    else if ((0, compiler_dom_1.isText)(value)) {
+        if ((0, shared_1.isString)(value.content)) {
+            return value.content;
+        }
+        else if (isSimpleExpressionNode(value.content)) {
+            return value.content.content;
+        }
+        else if (isCompoundExpressionNode(value.content)) {
+            return value.content.children.map(mapNodeContentHandler).join('');
+        }
+        else {
+            return '';
+        }
+    }
+    else {
+        return '';
+    }
+}
+function parseValue(value) {
+    if ((0, shared_1.isString)(value)) {
+        return [{ path: value }, 0 /* ReportCodes.SUCCESS */];
+    }
+    else if ((0, shared_1.isObject)(value)) {
+        if (!('path' in value)) {
+            return [null, 4 /* ReportCodes.REQUIRED_PARAMETER */];
+        }
+        return [value, 0 /* ReportCodes.SUCCESS */];
+    }
+    else {
+        return [null, 5 /* ReportCodes.INVALID_PARAMETER_TYPE */];
+    }
+}
+function makeParams(value) {
+    const { path, locale, args, choice, plural } = value;
+    const options = {};
+    const named = args || {};
+    if ((0, shared_1.isString)(locale)) {
+        options.locale = locale;
+    }
+    if ((0, shared_1.isNumber)(choice)) {
+        options.plural = choice;
+    }
+    if ((0, shared_1.isNumber)(plural)) {
+        options.plural = plural;
+    }
+    return [path, named, options];
+}
+function generateTranslationCode(context, mode, params, translationSignatures) {
+    return mode === 'composition'
+        ? generateComposableCode(context, params, translationSignatures)
+        : generateLegacyCode(context, params);
+}
+function generateTranslationCallableSignatures(context, translationSignatures) {
+    const { prefixIdentifiers, bindingMetadata } = context;
+    return translationSignatures
+        .map(signature => {
+        const type = (0, shared_1.hasOwn)(bindingMetadata, signature) && bindingMetadata[signature];
+        const bindingContext = prefixIdentifiers
+            ? (type && type.startsWith('setup')) || type === compiler_dom_1.BindingTypes.LITERAL_CONST
+                ? '$setup.'
+                : '_ctx.'
+            : '';
+        return `${bindingContext}${signature}`;
+    })
+        .join(' || ');
+}
+function generateComposableCode(context, params, translationSignatures) {
+    const baseCode = `(${generateTranslationCallableSignatures(context, translationSignatures)})`;
+    const builder = (0, builder_1.createContentBuilder)();
+    builder.push(`${baseCode}(`);
+    // generate path
+    builder.push(`${(0, shared_1.toDisplayString)(params.path)}`);
+    // generate named
+    builder.push(`, { `);
+    generateNamedCode(builder, params.named);
+    builder.push(` }`);
+    // generate options
+    builder.push(`, { `);
+    if (params.options.locale) {
+        builder.push(`locale: ${(0, shared_1.toDisplayString)(params.options.locale)}`);
+    }
+    if (params.options.plural) {
+        if (params.options.locale) {
+            builder.push(', ');
+        }
+        builder.push(`plural: ${(0, shared_1.toDisplayString)(params.options.plural)}`);
+    }
+    builder.push(` }`);
+    builder.push(`)`);
+    const content = builder.content;
+    return content;
+}
+function generateNamedCode(builder, named) {
+    const keys = Object.keys(named);
+    keys.forEach(k => {
+        const v = named[k];
+        if ((0, shared_1.isObject)(v)) {
+            builder.push(`${k}: { `);
+            generateNamedCode(builder, v);
+            builder.push(` }`);
+        }
+        else {
+            builder.push(`${k}: ${(0, shared_1.toDisplayString)(v)}`);
+        }
+    });
+}
+function generateLegacyCode(context, params) {
+    const mode = !params.options.plural ? 'basic' : 'plural';
+    const baseCode = `${context.prefixIdentifiers ? '_ctx.' : ''}${mode === 'basic' ? '$t' : '$tc'}`;
+    const builder = (0, builder_1.createContentBuilder)();
+    builder.push(`${baseCode}(`);
+    // generate path
+    builder.push(`${(0, shared_1.toDisplayString)(params.path)}`);
+    if (mode === 'basic') {
+        // generate locale
+        if ((0, shared_1.isString)(params.options.locale)) {
+            builder.push(`, ${(0, shared_1.toDisplayString)(params.options.locale)}`);
+        }
+        // generate named
+        builder.push(`, { `);
+        generateNamedCode(builder, params.named);
+        builder.push(` }`);
+    }
+    else {
+        // generate plural
+        builder.push(`, ${(0, shared_1.toDisplayString)(params.options.plural)}`);
+        if ((0, shared_1.isString)(params.options.locale)) {
+            // generate locale
+            builder.push(`, ${(0, shared_1.toDisplayString)(params.options.locale)}`);
+        }
+        else {
+            // generate named
+            builder.push(`, { `);
+            generateNamedCode(builder, params.named);
+            builder.push(` }`);
+        }
+    }
+    builder.push(`)`);
+    const content = builder.content;
+    return content;
+}

package/dist/cjs/transpiler.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVTExpression = exports.evaluateValue = void 0;
+const parser_1 = require("@babel/parser");
+function evaluateValue(expression) {
+    const ret = { status: 'ng', value: undefined };
+    try {
+        const ast = (0, parser_1.parse)(`const a = ${expression.trim()}`);
+        if (ast.program.body.length >= 1 &&
+            ast.program.body[0].type === 'VariableDeclaration' &&
+            ast.program.body[0].declarations.length >= 1) {
+            const node = ast.program.body[0].declarations[0].init;
+            if (node != null && (node.type === 'StringLiteral' || node.type === 'ObjectExpression')) {
+                // eslint-disable-next-line @typescript-eslint/no-implied-eval
+                const val = new Function(`return ${expression.trim()} `)();
+                ret.status = 'ok';
+                ret.value = val;
+            }
+        }
+        // eslint-disable-next-line no-empty
+    }
+    catch (_e) { }
+    return ret;
+}
+exports.evaluateValue = evaluateValue;
+function parseVTExpression(expression) {
+    const ret = {
+        path: '',
+        named: {},
+        options: {}
+    };
+    try {
+        const ast = (0, parser_1.parse)(`const a = ${expression.trim()}`);
+        if (ast.program.body.length >= 1 &&
+            ast.program.body[0].type === 'VariableDeclaration' &&
+            ast.program.body[0].declarations.length >= 1) {
+            const node = ast.program.body[0].declarations[0].init;
+            if (node != null) {
+                if (node.type === 'StringLiteral' && node.extra) {
+                    ret.path = node.extra.raw;
+                }
+                else if (node.type === 'Identifier') {
+                    ret.path = node.name;
+                }
+                else if (node.type === 'MemberExpression') {
+                    ret.path = getObjectMemberValue(node);
+                }
+                else if (node.type === 'ObjectExpression') {
+                    node.properties.forEach(propNode => {
+                        if (propNode.type === 'ObjectProperty') {
+                            const propKeyNode = propNode.key;
+                            if (propKeyNode.type !== 'Identifier') {
+                                return;
+                            }
+                            const propValueNode = propNode.value;
+                            switch (propKeyNode.name) {
+                                case 'path':
+                                    ret.path = getObjectMemberValue(propValueNode);
+                                    break;
+                                case 'locale':
+                                    ret.options.locale = getObjectMemberValue(propValueNode);
+                                    break;
+                                case 'choice':
+                                case 'plural':
+                                    ret.options.plural = getObjectMemberValue(propValueNode);
+                                    break;
+                                case 'args':
+                                    // console.log('args', propValueNode)
+                                    if (propValueNode.type === 'ObjectExpression') {
+                                        traverseObjectMember(propValueNode, ret.named);
+                                    }
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        // eslint-disable-next-line no-empty
+    }
+    catch (_e) { }
+    return ret;
+}
+exports.parseVTExpression = parseVTExpression;
+function getObjectMemberValue(node) {
+    if ((node.type === 'StringLiteral' || node.type === 'NumericLiteral') && node.extra) {
+        return node.extra.raw;
+    }
+    else if (node.type === 'Identifier') {
+        return node.name;
+    }
+    else if (node.type === 'MemberExpression') {
+        const paths = [];
+        collectMemberPath(node, paths);
+        paths.reverse();
+        return paths.join('.');
+    }
+    else {
+        return '';
+    }
+}
+function traverseObjectMember(node, target) {
+    node.properties.forEach(propNode => {
+        if (propNode.type === 'ObjectProperty') {
+            const propKeyNode = propNode.key;
+            if (propKeyNode.type !== 'Identifier') {
+                return;
+            }
+            if (!(propKeyNode.name in target)) {
+                target[propKeyNode.name] = {};
+            }
+            // console.log('propNode', propNode)
+            const propValueNode = propNode.value;
+            if (propValueNode.type === 'ObjectExpression') {
+                traverseObjectMember(propValueNode, target[propKeyNode.name]);
+            }
+            else {
+                target[propKeyNode.name] = getObjectMemberValue(propValueNode);
+            }
+        }
+    });
+}
+function collectMemberPath(node, paths) {
+    if (node.type === 'Identifier') {
+        paths.push(node.name);
+        return;
+    }
+    else if (node.type === 'MemberExpression' && node.property.type === 'Identifier') {
+        paths.push(node.property.name);
+        return collectMemberPath(node.object, paths);
+    }
+}

package/dist/esm/builder.js

@@ -0,0 +1,56 @@
+import { isNumber } from '@intlify/shared';
+/**
+ * Create a Content Builder
+ *
+ * @param options - Content Builder options
+ *
+ * @returns A {@link ContentBuilder} instance
+ *
+ * @public
+ */
+export function createContentBuilder(options = {}) {
+    let _indentLevel = options.indentLevel != null && isNumber(options.indentLevel) ? options.indentLevel : 0;
+    let _content = '';
+    function push(content) {
+        _content += content;
+    }
+    function _newline(n) {
+        push('\n' + `  `.repeat(n));
+    }
+    function newline() {
+        _newline(_indentLevel);
+    }
+    function pushline(content) {
+        push(content);
+        newline();
+    }
+    function indent(withoutNewLine) {
+        if (withoutNewLine) {
+            ++_indentLevel;
+        }
+        else {
+            _newline(++_indentLevel);
+        }
+    }
+    function deindent(withoutNewLine) {
+        if (withoutNewLine) {
+            --_indentLevel;
+        }
+        else {
+            _newline(--_indentLevel);
+        }
+    }
+    return {
+        get indentLevel() {
+            return _indentLevel;
+        },
+        get content() {
+            return String(_content);
+        },
+        push,
+        newline,
+        pushline,
+        indent,
+        deindent
+    };
+}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { transformVTDirective } from './transform';