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

package/dist/api/pseudoLocalize.js

@@ -1,60 +1,56 @@
 "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
-    };
-}
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = __importDefault(require("ramda"));
+const pseudolocale_1 = __importDefault(require("pseudolocale"));
 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;
+ */
+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;
+ */
+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;
+ */
+const VariableRegex = /({\s*[a-zA-Z_$][a-zA-Z_$0-9]*\s*})/g;
 function addDelimitersHTMLTags(message) {
-    return message.replace(HTMLRegex, (matchedString)=>{
+    return message.replace(HTMLRegex, (matchedString) => {
         return `${delimiter}${matchedString}${delimiter}`;
     });
 }
 function addDelimitersMacro(message) {
-    return message.replace(MacroRegex, (matchedString)=>{
+    return message.replace(MacroRegex, (matchedString) => {
         return `${delimiter}${matchedString}${delimiter}`;
     });
 }
 function addDelimitersVariables(message) {
-    return message.replace(VariableRegex, (matchedString)=>{
+    return message.replace(VariableRegex, (matchedString) => {
         return `${delimiter}${matchedString}${delimiter}`;
     });
 }
-const addDelimiters = _ramda.default.compose(addDelimitersVariables, addDelimitersMacro, addDelimitersHTMLTags);
+const addDelimiters = ramda_1.default.compose(addDelimitersVariables, addDelimitersMacro, addDelimitersHTMLTags);
 function removeDelimiters(message) {
     return message.replace(new RegExp(delimiter, "g"), "");
 }
-function _default(message) {
+function default_1(message) {
     message = addDelimiters(message);
-    message = _pseudolocale.default.str(message);
+    message = (0, pseudolocale_1.default)(message, {
+        delimiter,
+        prepend: "",
+        append: "",
+    });
     return removeDelimiters(message);
 }
+exports.default = default_1;

package/dist/api/rethrownError.d.ts

@@ -0,0 +1,4 @@
+export declare class RethrownError extends Error {
+    message: string;
+    constructor(message: string, originalError: Error);
+}

package/dist/api/rethrownError.js

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

package/dist/api/stats.d.ts

@@ -0,0 +1,6 @@
+import { LinguiConfigNormalized } from "@lingui/conf";
+import { AllCatalogsType, CatalogType } from "./types";
+type CatalogStats = [number, number];
+export declare function getStats(catalog: CatalogType): CatalogStats;
+export declare function printStats(config: LinguiConfigNormalized, catalogs: AllCatalogsType): any;
+export {};

package/dist/api/stats.js

@@ -1,73 +1,41 @@
 "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
-    };
-}
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printStats = exports.getStats = void 0;
+// @ts-ignore
+const cli_table_1 = __importDefault(require("cli-table"));
+const chalk_1 = __importDefault(require("chalk"));
 function getStats(catalog) {
     return [
         Object.keys(catalog).length,
-        Object.keys(catalog).filter((key)=>!catalog[key].translation).length
+        Object.keys(catalog).filter((key) => !catalog[key].translation).length,
     ];
 }
+exports.getStats = getStats;
 function printStats(config, catalogs) {
-    const table = new _cliTable.default({
-        head: [
-            "Language",
-            "Total count",
-            "Missing"
-        ],
-        colAligns: [
-            "left",
-            "middle",
-            "middle"
-        ],
+    const table = new cli_table_1.default({
+        head: ["Language", "Total count", "Missing"],
+        colAligns: ["left", "middle", "middle"],
         style: {
-            head: [
-                "green"
-            ],
+            head: ["green"],
             border: [],
-            compact: true
-        }
+            compact: true,
+        },
     });
-    Object.keys(catalogs).forEach((locale)=>{
+    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) : [
-            "-",
-            "-"
-        ];
+        const [all, translated] = catalog ? getStats(catalog) : ["-", "-"];
         if (config.sourceLocale === locale) {
-            table.push({
-                [`${_chalk.default.bold(locale)} (source)`]: [
-                    all,
-                    "-"
-                ]
-            });
-        } else {
-            table.push({
-                [locale]: [
-                    all,
-                    translated
-                ]
-            });
+            table.push({ [`${chalk_1.default.bold(locale)} (source)`]: [all, "-"] });
+        }
+        else {
+            table.push({ [locale]: [all, translated] });
         }
     });
     return table;
 }
+exports.printStats = printStats;

package/dist/api/types.d.ts

@@ -0,0 +1,5 @@
+import type { CatalogType } from "@lingui/conf";
+export type { MessageOrigin, ExtractedMessageType, MessageType, ExtractedCatalogType, CatalogType, } from "@lingui/conf";
+export type AllCatalogsType = {
+    [locale: string]: CatalogType;
+};

package/dist/api/types.js

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

package/dist/api/utils.d.ts

@@ -0,0 +1,22 @@
+export declare const PATHSEP = "/";
+export declare function prettyOrigin(origins: [filename: string, line?: number][]): string;
+export declare function replacePlaceholders(input: string, values: Record<string, string>): string;
+export declare const splitOrigin: (origin: string) => [file: string, line: number];
+export declare const joinOrigin: (origin: [file: string, line?: number]) => string;
+export declare function readFile(fileName: string): Promise<string | undefined>;
+export declare function isDirectory(filePath: string): boolean;
+export declare function writeFile(fileName: string, content: string): Promise<void>;
+export declare function writeFileIfChanged(filename: string, newContent: string): Promise<void>;
+export declare function hasYarn(): boolean;
+export declare function makeInstall(packageName: string, dev?: boolean): string;
+/**
+ * Normalize Windows backslashes in path so they look always as posix
+ */
+export declare function normalizeSlashes(path: string): string;
+/**
+ * Remove ./ at the beginning: ./relative  => relative
+ *                             relative    => relative
+ * Preserve directories:       ./relative/ => relative/
+ * Preserve absolute paths:    /absolute/path => /absolute/path
+ */
+export declare function normalizeRelativePath(sourcePath: string): string;

package/dist/api/utils.js

@@ -1,73 +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, {
-    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
-;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRelativePath = exports.normalizeSlashes = exports.makeInstall = exports.hasYarn = exports.writeFileIfChanged = exports.writeFile = exports.isDirectory = exports.readFile = exports.joinOrigin = exports.splitOrigin = exports.replacePlaceholders = exports.prettyOrigin = exports.PATHSEP = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const normalize_path_1 = __importDefault(require("normalize-path"));
+exports.PATHSEP = "/"; // force posix everywhere
 function prettyOrigin(origins) {
     try {
-        return origins.map((origin)=>origin.join(":")).join(", ");
-    } catch (e) {
+        return origins.map((origin) => origin.join(":")).join(", ");
+    }
+    catch (e) {
         return "";
     }
 }
+exports.prettyOrigin = prettyOrigin;
 function replacePlaceholders(input, values) {
-    return input.replace(/\{([^}]+)}/g, (m, placeholder)=>{
-        return values[placeholder] ?? m;
+    return input.replace(/\{([^}]+)}/g, (m, placeholder) => {
+        var _a;
+        return (_a = values[placeholder]) !== null && _a !== void 0 ? _a : m;
     });
 }
-const splitOrigin = (origin)=>{
+exports.replacePlaceholders = replacePlaceholders;
+const splitOrigin = (origin) => {
     const [file, line] = origin.split(":");
-    return [
-        file,
-        line ? Number(line) : null
-    ];
+    return [file, line ? Number(line) : null];
 };
-const joinOrigin = (origin)=>origin.join(":");
+exports.splitOrigin = splitOrigin;
+const joinOrigin = (origin) => origin.join(":");
+exports.joinOrigin = joinOrigin;
 async function readFile(fileName) {
     try {
-        return (await _fs.default.promises.readFile(fileName)).toString();
-    } catch (err) {
+        return (await fs_1.default.promises.readFile(fileName)).toString();
+    }
+    catch (err) {
         if (err.code != "ENOENT") {
             throw err;
         }
     }
 }
+exports.readFile = readFile;
 async function mkdirp(dir) {
     try {
-        await _fs.default.promises.mkdir(dir, {
-            recursive: true
+        await fs_1.default.promises.mkdir(dir, {
+            recursive: true,
         });
-    } catch (err) {
+    }
+    catch (err) {
         if (err.code != "EEXIST") {
             throw err;
         }
@@ -75,43 +56,64 @@ async function mkdirp(dir) {
 }
 function isDirectory(filePath) {
     try {
-        return _fs.default.lstatSync(filePath).isDirectory();
-    } catch (err) {
+        return fs_1.default.lstatSync(filePath).isDirectory();
+    }
+    catch (err) {
         if (err.code != "ENOENT") {
             throw err;
         }
     }
 }
+exports.isDirectory = isDirectory;
 async function writeFile(fileName, content) {
-    await mkdirp(_path.default.dirname(fileName));
-    await _fs.default.promises.writeFile(fileName, content);
+    await mkdirp(path_1.default.dirname(fileName));
+    await fs_1.default.promises.writeFile(fileName, content);
 }
+exports.writeFile = writeFile;
 async function writeFileIfChanged(filename, newContent) {
     const raw = await readFile(filename);
     if (raw) {
         if (newContent !== raw) {
             await writeFile(filename, newContent);
         }
-    } else {
+    }
+    else {
         await writeFile(filename, newContent);
     }
 }
+exports.writeFileIfChanged = writeFileIfChanged;
 function hasYarn() {
-    return _fs.default.existsSync(_path.default.resolve("yarn.lock"));
+    return fs_1.default.existsSync(path_1.default.resolve("yarn.lock"));
 }
+exports.hasYarn = hasYarn;
 function makeInstall(packageName, dev = false) {
     const withYarn = hasYarn();
-    return withYarn ? `yarn add ${dev ? "--dev " : ""}${packageName}` : `npm install ${dev ? "--save-dev" : "--save"} ${packageName}`;
+    return withYarn
+        ? `yarn add ${dev ? "--dev " : ""}${packageName}`
+        : `npm install ${dev ? "--save-dev" : "--save"} ${packageName}`;
 }
+exports.makeInstall = makeInstall;
+/**
+ * Normalize Windows backslashes in path so they look always as posix
+ */
 function normalizeSlashes(path) {
     return path.replace("\\", "/");
 }
+exports.normalizeSlashes = normalizeSlashes;
+/**
+ * Remove ./ at the beginning: ./relative  => relative
+ *                             relative    => relative
+ * Preserve directories:       ./relative/ => relative/
+ * Preserve absolute paths:    /absolute/path => /absolute/path
+ */
 function normalizeRelativePath(sourcePath) {
-    if (_path.default.isAbsolute(sourcePath)) {
+    if (path_1.default.isAbsolute(sourcePath)) {
         // absolute path
-        return (0, _normalizePath.default)(sourcePath, false);
+        return (0, normalize_path_1.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 ? "/" : "");
+    return ((0, normalize_path_1.default)(path_1.default.relative(process.cwd(), sourcePath), false) +
+        (isDir ? "/" : ""));
 }
+exports.normalizeRelativePath = normalizeRelativePath;

package/dist/extract-experimental/buildExternalizeFilter.d.ts

@@ -0,0 +1,13 @@
+type PackageJson = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+};
+export declare function buildExternalizeFilter({ includeDeps, excludeDeps, packageJson, }: {
+    includeDeps: string[];
+    excludeDeps: string[];
+    packageJson: PackageJson;
+}): (id: string) => boolean;
+export declare function getPackageJson(rootDir: string): Promise<PackageJson>;
+export {};

package/dist/extract-experimental/buildExternalizeFilter.js

@@ -1,83 +1,38 @@
 "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;
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = exports.buildExternalizeFilter = void 0;
 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);
+    return Object.keys(packages || {})
+        .filter((packageName) => {
+        return !includeDeps.some((incl) => packageName.startsWith(incl));
+    })
+        .map(createPackageRegExp);
 }
-function buildExternalizeFilter({ includeDeps , excludeDeps , packageJson  }) {
+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)
+        ...excludeDeps.map(createPackageRegExp),
     ];
-    return (id)=>external.some((regExp)=>{
-            return regExp.test(id);
-        });
+    return (id) => external.some((regExp) => {
+        return regExp.test(id);
+    });
 }
+exports.buildExternalizeFilter = buildExternalizeFilter;
 async function getPackageJson(rootDir) {
-    const { default: pkgUp  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("pkg-up")));
+    const { default: pkgUp } = await import("pkg-up");
     const packageJsonPath = await pkgUp({
-        cwd: rootDir
+        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");
+        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)));
+    return await import(packageJsonPath);
 }
+exports.getPackageJson = getPackageJson;

package/dist/extract-experimental/bundleSource.d.ts

@@ -0,0 +1,2 @@
+import { ExperimentalExtractorOptions } from "@lingui/conf";
+export declare function bundleSource(config: ExperimentalExtractorOptions, entryPoints: string[], outDir: string, rootDir: string): Promise<import("esbuild").BuildResult<any>>;