@lingui/cli 4.0.0-next.4 → 4.0.0-next.5

package/dist/api/compile.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createCompiledCatalog: ()=>createCompiledCatalog,
+    compile: ()=>compile
+});
+const _types = /*#__PURE__*/ _interopRequireWildcard(require("@babel/types"));
+const _generator = /*#__PURE__*/ _interopRequireDefault(require("@babel/generator"));
+const _compileMessage = require("@lingui/message-utils/compileMessage");
+const _pseudoLocalize = /*#__PURE__*/ _interopRequireDefault(require("./pseudoLocalize"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function createCompiledCatalog(locale, messages, options) {
+    const { strict =false , namespace ="cjs" , pseudoLocale , compilerBabelOptions ={}  } = options;
+    const shouldPseudolocalize = locale === pseudoLocale;
+    const compiledMessages = Object.keys(messages).reduce((obj, key)=>{
+        // Don't use `key` as a fallback translation in strict mode.
+        const translation = messages[key] || (!strict ? key : "");
+        obj[key] = compile(translation, shouldPseudolocalize);
+        return obj;
+    }, {});
+    if (namespace === "json") {
+        return JSON.stringify({
+            messages: compiledMessages
+        });
+    }
+    const ast = buildExportStatement(//build JSON.parse(<compiledMessages>) statement
+    _types.callExpression(_types.memberExpression(_types.identifier("JSON"), _types.identifier("parse")), [
+        _types.stringLiteral(JSON.stringify(compiledMessages))
+    ]), namespace);
+    const code = (0, _generator.default)(ast, {
+        minified: true,
+        jsescOption: {
+            minimal: true
+        },
+        ...compilerBabelOptions
+    }).code;
+    return "/*eslint-disable*/" + code;
+}
+function buildExportStatement(expression, namespace) {
+    if (namespace === "es" || namespace === "ts") {
+        // export const messages = { message: "Translation" }
+        return _types.exportNamedDeclaration(_types.variableDeclaration("const", [
+            _types.variableDeclarator(_types.identifier("messages"), expression)
+        ]));
+    } else {
+        let exportExpression = null;
+        const matches = namespace.match(/^(window|global)\.([^.\s]+)$/);
+        if (namespace === "cjs") {
+            // module.exports.messages = { message: "Translation" }
+            exportExpression = _types.memberExpression(_types.identifier("module"), _types.identifier("exports"));
+        } else if (matches) {
+            // window.i18nMessages = { messages: { message: "Translation" }}
+            exportExpression = _types.memberExpression(_types.identifier(matches[1]), _types.identifier(matches[2]));
+        } else {
+            throw new Error(`Invalid namespace param: "${namespace}"`);
+        }
+        return _types.expressionStatement(_types.assignmentExpression("=", exportExpression, _types.objectExpression([
+            _types.objectProperty(_types.identifier("messages"), expression)
+        ])));
+    }
+}
+function compile(message, shouldPseudolocalize = false) {
+    return (0, _compileMessage.compileMessage)(message, (value)=>shouldPseudolocalize ? (0, _pseudoLocalize.default)(value) : value);
+}

package/dist/api/extractors/babel.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _core = require("@babel/core");
+const _babelPluginExtractMessages = /*#__PURE__*/ _interopRequireDefault(require("@lingui/babel-plugin-extract-messages"));
+const _sourceMap = require("source-map");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const babelRe = new RegExp("\\.(" + [
+    ..._core.DEFAULT_EXTENSIONS,
+    ".ts",
+    ".mts",
+    ".cts",
+    ".tsx"
+].map((ext)=>ext.slice(1)).join("|") + ")$", "i");
+const inlineSourceMapsRE = new RegExp(/\/[\/\*][#@]\s+sourceMappingURL=data:application\/json;(?:charset:utf-8;)?base64,/i);
+const extractor = {
+    match (filename) {
+        return babelRe.test(filename);
+    },
+    async extract (filename, code, onMessageExtracted, ctx) {
+        const parserOptions = ctx.linguiConfig.extractorParserOptions;
+        // https://babeljs.io/docs/en/babel-parser#latest-ecmascript-features
+        const parserPlugins = [];
+        if ([
+            /\.ts$/,
+            /\.mts$/,
+            /\.cts$/,
+            /\.tsx$/
+        ].some((r)=>filename.match(r))) {
+            parserPlugins.push("typescript");
+            if (parserOptions.tsExperimentalDecorators) {
+                parserPlugins.push("decorators-legacy");
+            } else {
+                parserPlugins.push("decorators");
+            }
+        } else {
+            parserPlugins.push("decorators");
+            if (parserOptions === null || parserOptions === void 0 ? void 0 : parserOptions.flow) {
+                parserPlugins.push("flow");
+            }
+        }
+        if ([
+            /\.jsx$/,
+            /\.tsx$/
+        ].some((r)=>filename.match(r))) {
+            parserPlugins.push("jsx");
+        }
+        let sourceMapsConsumer;
+        if (ctx === null || ctx === void 0 ? void 0 : ctx.sourceMaps) {
+            sourceMapsConsumer = await new _sourceMap.SourceMapConsumer(ctx === null || ctx === void 0 ? void 0 : ctx.sourceMaps);
+        } else if (code.search(inlineSourceMapsRE) != -1) {
+            const { fromSource  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("convert-source-map")));
+            sourceMapsConsumer = await new _sourceMap.SourceMapConsumer(fromSource(code).toObject());
+        }
+        await (0, _core.transformAsync)(code, {
+            // don't generate code
+            code: false,
+            babelrc: false,
+            configFile: false,
+            filename: filename,
+            inputSourceMap: ctx === null || ctx === void 0 ? void 0 : ctx.sourceMaps,
+            parserOpts: {
+                plugins: parserPlugins
+            },
+            plugins: [
+                [
+                    "macros",
+                    {
+                        // macro plugin uses package `resolve` to find a path of macro file
+                        // this will not follow jest pathMapping and will resolve path from ./build
+                        // instead of ./src which makes testing & developing hard.
+                        // here we override resolve and provide correct path for testing
+                        resolvePath: (source)=>require.resolve(source),
+                        lingui: {
+                            extract: true,
+                            linguiConfig: ctx.linguiConfig
+                        }
+                    }
+                ],
+                [
+                    _babelPluginExtractMessages.default,
+                    {
+                        onMessageExtracted: (msg)=>{
+                            if (!sourceMapsConsumer) {
+                                return onMessageExtracted(msg);
+                            }
+                            const [_, line, column] = msg.origin;
+                            const mappedPosition = sourceMapsConsumer.originalPositionFor({
+                                line,
+                                column
+                            });
+                            return onMessageExtracted({
+                                ...msg,
+                                origin: [
+                                    mappedPosition.source,
+                                    mappedPosition.line,
+                                    mappedPosition.column
+                                ]
+                            });
+                        }
+                    }
+                ]
+            ]
+        });
+        if (sourceMapsConsumer) {
+            sourceMapsConsumer.destroy();
+        }
+    }
+};
+const _default = extractor;

package/dist/api/extractors/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>extract
+});
+const _promises = /*#__PURE__*/ _interopRequireDefault(require("fs/promises"));
+const _babel = /*#__PURE__*/ _interopRequireDefault(require("./babel"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DEFAULT_EXTRACTORS = [
+    _babel.default
+];
+async function extract(filename, onMessageExtracted, linguiConfig, options) {
+    const extractorsToExtract = options.extractors ?? DEFAULT_EXTRACTORS;
+    for (let e of extractorsToExtract){
+        let ext = e;
+        if (typeof e === "string") {
+            // in case of the user using require.resolve in their extractors, we require that module
+            ext = require(e);
+        }
+        if (ext.default) {
+            ext = ext.default;
+        }
+        if (!ext.match(filename)) continue;
+        try {
+            const file = await _promises.default.readFile(filename);
+            await ext.extract(filename, file.toString(), onMessageExtracted, {
+                linguiConfig
+            });
+            return true;
+        } catch (e) {
+            console.error(`Cannot process file ${filename} ${e.message}`);
+            console.error(e.stack);
+            return false;
+        }
+    }
+    return true;
+}

package/dist/api/extractors/typescript.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const extractor = {
+    match (filename) {
+        throw new Error("Typescript extractor was removed. " + "Lingui CLI can parse typescript out of the box. " + "Please remove it from your lingui.config.js");
+    },
+    extract () {}
+};
+const _default = extractor;

package/dist/api/formats/formatterWrapper.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FormatterWrapper", {
+    enumerable: true,
+    get: ()=>FormatterWrapper
+});
+const _utils = require("../utils");
+const _rethrownError = require("../rethrownError");
+class FormatterWrapper {
+    f;
+    sourceLocale;
+    constructor(f, sourceLocale){
+        this.f = f;
+        this.sourceLocale = sourceLocale;
+    }
+    getCatalogExtension() {
+        return this.f.catalogExtension;
+    }
+    getTemplateExtension() {
+        return this.f.templateExtension || this.f.catalogExtension;
+    }
+    async write(filename, catalog, locale) {
+        const content = await this.f.serialize(catalog, {
+            locale,
+            sourceLocale: this.sourceLocale,
+            existing: await (0, _utils.readFile)(filename),
+            filename
+        });
+        await (0, _utils.writeFileIfChanged)(filename, content);
+    }
+    async read(filename, locale) {
+        const content = await (0, _utils.readFile)(filename);
+        if (!content) {
+            return null;
+        }
+        try {
+            return this.f.parse(content, {
+                locale,
+                sourceLocale: this.sourceLocale,
+                filename
+            });
+        } catch (e) {
+            throw new _rethrownError.RethrownError(`Cannot read ${filename}`, e);
+        }
+    }
+}

package/dist/api/formats/index.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    FormatterWrapper: ()=>_formatterWrapper.FormatterWrapper,
+    getFormat: ()=>getFormat
+});
+const _formatterWrapper = require("./formatterWrapper");
+const _utils = require("../utils");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function createDeprecationError(packageName, format, installCode) {
+    const installCmd = (0, _utils.makeInstall)(packageName);
+    return `
+Format \`${format}\` is no longer included in \`@lingui/cli\` by default.
+You need to install it using ${installCmd} command and add to your \`lingui.config.{js,ts}\`:
+        
+import { formatter } from "${packageName}"
+
+export default {
+  [...]
+  format: ${installCode}
+}
+`.trim();
+}
+// Introduced in v4. Remove this deprecation in v5
+const formats = {
+    lingui: async ()=>{
+        throw new Error(createDeprecationError("@lingui/format-json", "lingui", 'formatter({style: "lingui"})'));
+    },
+    minimal: async ()=>{
+        throw new Error(createDeprecationError("@lingui/format-json", "minimal", 'formatter({style: "minimal"})'));
+    },
+    po: async ()=>(await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("@lingui/format-po")))).formatter,
+    csv: async ()=>{
+        throw new Error(createDeprecationError("@lingui/format-csv", "csv", "formatter()"));
+    },
+    "po-gettext": async ()=>{
+        throw new Error(createDeprecationError("@lingui/format-po-gettext", "po-gettext", "formatter()"));
+    }
+};
+async function getFormat(_format, options, sourceLocale) {
+    if (typeof _format !== "string") {
+        return new _formatterWrapper.FormatterWrapper(_format, sourceLocale);
+    }
+    const format = formats[_format];
+    if (!format) {
+        throw new Error(`Unknown format "${_format}". Use one of following: ${Object.keys(formats).join(", ")}`);
+    }
+    return new _formatterWrapper.FormatterWrapper((await format())(options), sourceLocale);
+}

package/dist/api/help.js

@@ -0,0 +1,41 @@
+/**
+ * Detect where's is the command lingui extract or lingui compile
+ * and how is being run (npm, yarn) and construct help
+ * for follow-up commands based on that.
+ *
+ * Example:
+ * $ yarn extract
+ * ...
+ * (use "yarn compile" to compile catalogs for production)
+ *
+ * $ yarn lingui extract
+ * ...
+ * (use "yarn lingui compile" to compile catalogs for production)
+ *
+ * $ npm run extract
+ * ...
+ * (use "npm run compile" to compile catalogs for production)
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "helpRun", {
+    enumerable: true,
+    get: ()=>helpRun
+});
+const _path = require("path");
+function helpRun(command) {
+    let findRootPkgJson;
+    try {
+        findRootPkgJson = require((0, _path.resolve)((0, _path.join)(process.cwd(), "package.json")));
+    } catch (error) {}
+    if (findRootPkgJson === null || findRootPkgJson === void 0 ? void 0 : findRootPkgJson.scripts) {
+        const res = Object.entries(findRootPkgJson.scripts).find(([_, value])=>value.includes(`lingui ${command}`));
+        if (res) {
+            command = res[0];
+        }
+    }
+    const isYarn = process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes("yarn");
+    const runCommand = isYarn ? "yarn" : "npm run";
+    return `${runCommand} ${command}`;
+}

package/dist/api/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getFormat: ()=>_formats.getFormat,
+    getCatalogForFile: ()=>_getCatalogs.getCatalogForFile,
+    getCatalogs: ()=>_getCatalogs.getCatalogs,
+    createCompiledCatalog: ()=>_compile.createCompiledCatalog
+});
+const _formats = require("./formats");
+const _getCatalogs = require("./catalog/getCatalogs");
+const _compile = require("./compile");
+_exportStar(require("./types"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}

package/dist/api/pseudoLocalize.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _ramda = /*#__PURE__*/ _interopRequireDefault(require("ramda"));
+const _pseudolocale = /*#__PURE__*/ _interopRequireDefault(require("pseudolocale"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const delimiter = "%&&&%";
+_pseudolocale.default.option.delimiter = delimiter;
+// We do not want prepending and appending because of Plurals structure
+_pseudolocale.default.option.prepend = "";
+_pseudolocale.default.option.append = "";
+/**
+ * Regex should match HTML tags
+ * It was taken from https://haacked.com/archive/2004/10/25/usingregularexpressionstomatchhtml.aspx/
+ * Example: https://regex101.com/r/bDHD9z/3
+ */ const HTMLRegex = /<\/?\w+((\s+\w+(\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)+\s*|\s*)\/?>/g;
+/**
+ * Regex should match js-lingui Plurals, Select and SelectOrdinal  components
+ * Example:
+ * Plurals https://regex101.com/r/VUJXg0/1
+ * SelectOrdinal https://regex101.com/r/T7hSLU/2
+ * Select https://regex101.com/r/9JnqB9/1
+ */ const MacroRegex = /({\w*,\s*(plural|selectordinal|select),(.|\n)*?{)|(}\s*\w*\s*{)/gi;
+/**
+ * Regex should match js-lingui variables
+ * Example: https://regex101.com/r/dw1QHb/2
+ */ const VariableRegex = /({\s*[a-zA-Z_$][a-zA-Z_$0-9]*\s*})/g;
+function addDelimitersHTMLTags(message) {
+    return message.replace(HTMLRegex, (matchedString)=>{
+        return `${delimiter}${matchedString}${delimiter}`;
+    });
+}
+function addDelimitersMacro(message) {
+    return message.replace(MacroRegex, (matchedString)=>{
+        return `${delimiter}${matchedString}${delimiter}`;
+    });
+}
+function addDelimitersVariables(message) {
+    return message.replace(VariableRegex, (matchedString)=>{
+        return `${delimiter}${matchedString}${delimiter}`;
+    });
+}
+const addDelimiters = _ramda.default.compose(addDelimitersVariables, addDelimitersMacro, addDelimitersHTMLTags);
+function removeDelimiters(message) {
+    return message.replace(new RegExp(delimiter, "g"), "");
+}
+function _default(message) {
+    message = addDelimiters(message);
+    message = _pseudolocale.default.str(message);
+    return removeDelimiters(message);
+}

package/dist/api/rethrownError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RethrownError", {
+    enumerable: true,
+    get: ()=>RethrownError
+});
+class RethrownError extends Error {
+    message;
+    constructor(message, originalError){
+        super();
+        this.message = message + " " + originalError.message;
+        this.stack = `Error: ${message} \nOriginal: ` + originalError.stack;
+    }
+}