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

package/dist/api/stats.js

@@ -0,0 +1,73 @@
+"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, {
+    getStats: ()=>getStats,
+    printStats: ()=>printStats
+});
+const _cliTable = /*#__PURE__*/ _interopRequireDefault(require("cli-table"));
+const _chalk = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getStats(catalog) {
+    return [
+        Object.keys(catalog).length,
+        Object.keys(catalog).filter((key)=>!catalog[key].translation).length
+    ];
+}
+function printStats(config, catalogs) {
+    const table = new _cliTable.default({
+        head: [
+            "Language",
+            "Total count",
+            "Missing"
+        ],
+        colAligns: [
+            "left",
+            "middle",
+            "middle"
+        ],
+        style: {
+            head: [
+                "green"
+            ],
+            border: [],
+            compact: true
+        }
+    });
+    Object.keys(catalogs).forEach((locale)=>{
+        const catalog = catalogs[locale];
+        // catalog is null if no catalog exists on disk and the locale
+        // was not extracted due to a `--locale` filter
+        const [all, translated] = catalog ? getStats(catalog) : [
+            "-",
+            "-"
+        ];
+        if (config.sourceLocale === locale) {
+            table.push({
+                [`${_chalk.default.bold(locale)} (source)`]: [
+                    all,
+                    "-"
+                ]
+            });
+        } else {
+            table.push({
+                [locale]: [
+                    all,
+                    translated
+                ]
+            });
+        }
+    });
+    return table;
+}

package/{build → dist}/api/types.js

@@ -1,5 +1,4 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+    value: true
+});

package/dist/api/utils.js

@@ -0,0 +1,117 @@
+"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, {
+    PATHSEP: ()=>PATHSEP,
+    prettyOrigin: ()=>prettyOrigin,
+    replacePlaceholders: ()=>replacePlaceholders,
+    splitOrigin: ()=>splitOrigin,
+    joinOrigin: ()=>joinOrigin,
+    readFile: ()=>readFile,
+    isDirectory: ()=>isDirectory,
+    writeFile: ()=>writeFile,
+    writeFileIfChanged: ()=>writeFileIfChanged,
+    hasYarn: ()=>hasYarn,
+    makeInstall: ()=>makeInstall,
+    normalizeSlashes: ()=>normalizeSlashes,
+    normalizeRelativePath: ()=>normalizeRelativePath
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _normalizePath = /*#__PURE__*/ _interopRequireDefault(require("normalize-path"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const PATHSEP = "/" // force posix everywhere
+;
+function prettyOrigin(origins) {
+    try {
+        return origins.map((origin)=>origin.join(":")).join(", ");
+    } catch (e) {
+        return "";
+    }
+}
+function replacePlaceholders(input, values) {
+    return input.replace(/\{([^}]+)}/g, (m, placeholder)=>{
+        return values[placeholder] ?? m;
+    });
+}
+const splitOrigin = (origin)=>{
+    const [file, line] = origin.split(":");
+    return [
+        file,
+        line ? Number(line) : null
+    ];
+};
+const joinOrigin = (origin)=>origin.join(":");
+async function readFile(fileName) {
+    try {
+        return (await _fs.default.promises.readFile(fileName)).toString();
+    } catch (err) {
+        if (err.code != "ENOENT") {
+            throw err;
+        }
+    }
+}
+async function mkdirp(dir) {
+    try {
+        await _fs.default.promises.mkdir(dir, {
+            recursive: true
+        });
+    } catch (err) {
+        if (err.code != "EEXIST") {
+            throw err;
+        }
+    }
+}
+function isDirectory(filePath) {
+    try {
+        return _fs.default.lstatSync(filePath).isDirectory();
+    } catch (err) {
+        if (err.code != "ENOENT") {
+            throw err;
+        }
+    }
+}
+async function writeFile(fileName, content) {
+    await mkdirp(_path.default.dirname(fileName));
+    await _fs.default.promises.writeFile(fileName, content);
+}
+async function writeFileIfChanged(filename, newContent) {
+    const raw = await readFile(filename);
+    if (raw) {
+        if (newContent !== raw) {
+            await writeFile(filename, newContent);
+        }
+    } else {
+        await writeFile(filename, newContent);
+    }
+}
+function hasYarn() {
+    return _fs.default.existsSync(_path.default.resolve("yarn.lock"));
+}
+function makeInstall(packageName, dev = false) {
+    const withYarn = hasYarn();
+    return withYarn ? `yarn add ${dev ? "--dev " : ""}${packageName}` : `npm install ${dev ? "--save-dev" : "--save"} ${packageName}`;
+}
+function normalizeSlashes(path) {
+    return path.replace("\\", "/");
+}
+function normalizeRelativePath(sourcePath) {
+    if (_path.default.isAbsolute(sourcePath)) {
+        // absolute path
+        return (0, _normalizePath.default)(sourcePath, false);
+    }
+    // https://github.com/lingui/js-lingui/issues/809
+    const isDir = isDirectory(sourcePath);
+    return (0, _normalizePath.default)(_path.default.relative(process.cwd(), sourcePath), false) + (isDir ? "/" : "");
+}

package/dist/extract-experimental/buildExternalizeFilter.js

@@ -0,0 +1,83 @@
+"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, {
+    buildExternalizeFilter: ()=>buildExternalizeFilter,
+    getPackageJson: ()=>getPackageJson
+});
+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 createPackageRegExp(packageName) {
+    return new RegExp("^" + packageName + "(?:\\/.+)?");
+}
+function packages(packages, includeDeps) {
+    return Object.keys(packages || {}).filter((packageName)=>{
+        return !includeDeps.some((incl)=>packageName.startsWith(incl));
+    }).map(createPackageRegExp);
+}
+function buildExternalizeFilter({ includeDeps , excludeDeps , packageJson  }) {
+    const external = [
+        ...packages(packageJson.dependencies, includeDeps),
+        ...packages(packageJson.devDependencies, includeDeps),
+        ...packages(packageJson.peerDependencies, includeDeps),
+        ...packages(packageJson.optionalDependencies, includeDeps),
+        ...excludeDeps.map(createPackageRegExp)
+    ];
+    return (id)=>external.some((regExp)=>{
+            return regExp.test(id);
+        });
+}
+async function getPackageJson(rootDir) {
+    const { default: pkgUp  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("pkg-up")));
+    const packageJsonPath = await pkgUp({
+        cwd: rootDir
+    });
+    if (!packageJsonPath) {
+        throw new Error("We could not able to find your package.json file. " + "Check that `rootDir` is pointing to the folder with package.json");
+    }
+    return await Promise.resolve(packageJsonPath).then((p)=>/*#__PURE__*/ _interopRequireWildcard(require(p)));
+}

package/dist/extract-experimental/bundleSource.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "bundleSource", {
+    enumerable: true,
+    get: ()=>bundleSource
+});
+const _buildExternalizeFilter = require("./buildExternalizeFilter");
+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 createExtRegExp(extensions) {
+    return new RegExp("\\.(?:" + extensions.join("|") + ")(?:\\?.*)?$");
+}
+async function bundleSource(config, entryPoints, outDir, rootDir) {
+    const esbuild = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("esbuild")));
+    const excludeExtensions = config.excludeExtensions || [
+        "ico",
+        "pot",
+        "xliff",
+        "woff2",
+        "woff",
+        "eot",
+        "gif",
+        "otf",
+        "ttf",
+        "mp4",
+        "svg",
+        "png",
+        "css",
+        "sass",
+        "less",
+        "jpg"
+    ];
+    const packageJson = await (0, _buildExternalizeFilter.getPackageJson)(rootDir);
+    const esbuildOptions = {
+        entryPoints: entryPoints,
+        outExtension: {
+            ".js": ".jsx"
+        },
+        jsx: "preserve",
+        bundle: true,
+        platform: "node",
+        target: [
+            "esnext"
+        ],
+        format: "esm",
+        splitting: false,
+        treeShaking: true,
+        outdir: outDir,
+        sourcemap: "inline",
+        sourceRoot: outDir,
+        sourcesContent: false,
+        outbase: rootDir,
+        metafile: true,
+        plugins: [
+            {
+                name: "externalize-deps",
+                setup (build) {
+                    const isExternal = (0, _buildExternalizeFilter.buildExternalizeFilter)({
+                        includeDeps: config.includeDeps || [],
+                        excludeDeps: config.excludeDeps || [],
+                        packageJson
+                    });
+                    // externalize bare imports
+                    build.onResolve({
+                        filter: /^[^.].*/
+                    }, async ({ path: id  })=>{
+                        if (isExternal(id)) {
+                            return {
+                                external: true
+                            };
+                        }
+                    });
+                }
+            },
+            {
+                name: "externalize-files",
+                setup (build) {
+                    build.onResolve({
+                        filter: createExtRegExp(excludeExtensions)
+                    }, ()=>({
+                            external: true
+                        }));
+                }
+            }
+        ]
+    };
+    return await esbuild.build(config.resolveEsbuildOptions ? config.resolveEsbuildOptions(esbuildOptions) : esbuildOptions);
+}

package/dist/extract-experimental/constants.js

@@ -0,0 +1,16 @@
+"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, {
+    ENTRY_NAME_PH: ()=>ENTRY_NAME_PH,
+    DEFAULT_TEMPLATE_NAME: ()=>DEFAULT_TEMPLATE_NAME
+});
+const ENTRY_NAME_PH = "{entryName}";
+const DEFAULT_TEMPLATE_NAME = "messages";

package/dist/extract-experimental/getEntryPoints.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getEntryPoints", {
+    enumerable: true,
+    get: ()=>getEntryPoints
+});
+const _glob = /*#__PURE__*/ _interopRequireDefault(require("glob"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getEntryPoints(entries) {
+    const patterns = entries.length > 1 ? `{${entries.join(",")}}` : entries[0];
+    return _glob.default.sync(patterns, {
+        mark: true
+    });
+}

package/dist/extract-experimental/getExperimentalCatalogs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getExperimentalCatalogs", {
+    enumerable: true,
+    get: ()=>getExperimentalCatalogs
+});
+const _getEntryPoints = require("./getEntryPoints");
+const _resolveCatalogPath = require("./resolveCatalogPath");
+const _catalog = require("../api/catalog");
+const _resolveTemplatePath = require("./resolveTemplatePath");
+const _api = require("@lingui/cli/api");
+async function getExperimentalCatalogs(linguiConfig) {
+    const config = linguiConfig.experimental.extractor;
+    const entryPoints = (0, _getEntryPoints.getEntryPoints)(config.entries);
+    const format = await (0, _api.getFormat)(linguiConfig.format, linguiConfig.formatOptions, linguiConfig.sourceLocale);
+    return entryPoints.map((entryPoint)=>{
+        const catalogPath = (0, _resolveCatalogPath.resolveCatalogPath)(config.output, entryPoint, linguiConfig.rootDir, undefined, "");
+        const templatePath = (0, _resolveTemplatePath.resolveTemplatePath)(entryPoint, config.output, linguiConfig.rootDir, format.getTemplateExtension());
+        return new _catalog.Catalog({
+            name: undefined,
+            path: catalogPath,
+            templatePath,
+            include: [],
+            exclude: [],
+            format
+        }, linguiConfig);
+    });
+}

package/dist/extract-experimental/resolveCatalogPath.js

@@ -0,0 +1,34 @@
+"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, {
+    resolveCatalogPath: ()=>resolveCatalogPath,
+    getEntryName: ()=>getEntryName
+});
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _utils = require("../api/utils");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function resolveCatalogPath(configOutput, entryPath, rootDir, locale, extension) {
+    const entryName = getEntryName(entryPath);
+    const entryDir = _path.default.relative(rootDir, _path.default.dirname(entryPath));
+    return _path.default.normalize((0, _utils.replacePlaceholders)(configOutput, {
+        entryName,
+        entryDir,
+        locale
+    }) + extension);
+}
+function getEntryName(entryPath) {
+    const parsedPath = _path.default.parse(entryPath);
+    return parsedPath.name.replace(parsedPath.ext, "");
+}

package/dist/extract-experimental/resolveTemplatePath.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveTemplatePath", {
+    enumerable: true,
+    get: ()=>resolveTemplatePath
+});
+const _resolveCatalogPath = require("./resolveCatalogPath");
+const _constants = require("./constants");
+function resolveTemplatePath(entryPoint, output, rootDir, catalogExtension) {
+    let templateName;
+    if (output.includes(_constants.ENTRY_NAME_PH)) {
+        templateName = _constants.DEFAULT_TEMPLATE_NAME;
+    } else {
+        templateName = (0, _resolveCatalogPath.getEntryName)(entryPoint);
+    }
+    return (0, _resolveCatalogPath.resolveCatalogPath)(output, entryPoint, rootDir, templateName, catalogExtension);
+}

package/dist/extract-experimental/writeCatalogs.js

@@ -0,0 +1,54 @@
+"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, {
+    writeCatalogs: ()=>writeCatalogs,
+    writeTemplate: ()=>writeTemplate
+});
+const _resolveTemplatePath = require("./resolveTemplatePath");
+const _chalk = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+const _resolveCatalogPath = require("./resolveCatalogPath");
+const _mergeCatalog = require("../api/catalog/mergeCatalog");
+const _stats = require("../api/stats");
+const _catalog = require("../api/catalog");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function cleanAndSort(catalog, clean, orderBy) {
+    if (clean) {
+        catalog = (0, _catalog.cleanObsolete)(catalog);
+    }
+    return (0, _catalog.order)(orderBy)(catalog);
+}
+async function writeCatalogs(params) {
+    const { entryPoint , outputPattern , linguiConfig , locales , overwrite , format , clean , messages  } = params;
+    const stat = {};
+    for (const locale of locales){
+        const catalogOutput = (0, _resolveCatalogPath.resolveCatalogPath)(outputPattern, entryPoint, linguiConfig.rootDir, locale, format.getCatalogExtension());
+        const catalog = (0, _mergeCatalog.mergeCatalog)(await format.read(catalogOutput, locale), messages, locale === linguiConfig.sourceLocale, {
+            overwrite
+        });
+        await format.write(catalogOutput, cleanAndSort(catalog, clean, linguiConfig.orderBy), locale);
+        stat[locale] = catalog;
+    }
+    return {
+        statMessage: (0, _stats.printStats)(linguiConfig, stat).toString()
+    };
+}
+async function writeTemplate(params) {
+    const { entryPoint , outputPattern , linguiConfig , format , clean , messages  } = params;
+    const catalogOutput = (0, _resolveTemplatePath.resolveTemplatePath)(entryPoint, outputPattern, linguiConfig.rootDir, format.getTemplateExtension());
+    await format.write(catalogOutput, cleanAndSort(messages, clean, linguiConfig.orderBy), undefined);
+    return {
+        statMessage: `${_chalk.default.bold(Object.keys(messages).length)} message(s) extracted`
+    };
+}