@lingui/cli 5.9.1 → 6.0.0-next.0

package/dist/api/catalog.js

@@ -1,36 +1,34 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderByMessage = exports.Catalog = void 0;
-exports.cleanObsolete = cleanObsolete;
-exports.order = order;
-exports.writeCompiled = writeCompiled;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const glob_1 = require("glob");
-const normalize_path_1 = __importDefault(require("normalize-path"));
-const getTranslationsForCatalog_1 = require("./catalog/getTranslationsForCatalog");
-const mergeCatalog_1 = require("./catalog/mergeCatalog");
-const extractFromFiles_1 = require("./catalog/extractFromFiles");
-const utils_1 = require("./utils");
+import fs from "fs";
+import path from "path";
+import { globSync } from "node:fs";
+import normalize from "normalize-path";
+import { getTranslationsForCatalog, } from "./catalog/getTranslationsForCatalog.js";
+import { mergeCatalog } from "./catalog/mergeCatalog.js";
+import { extractFromFiles, extractFromFilesWithWorkerPool, } from "./catalog/extractFromFiles.js";
+import { isDirectory, makePathRegexSafe, normalizeRelativePath, replacePlaceholders, writeFile, } from "./utils.js";
 const LOCALE = "{locale}";
 const LOCALE_SUFFIX_RE = /\{locale\}.*$/;
-class Catalog {
+export class Catalog {
+    config;
+    name;
+    path;
+    include;
+    exclude;
+    format;
+    templateFile;
     constructor({ name, path, include, templatePath, format, exclude = [] }, config) {
         this.config = config;
         this.name = name;
-        this.path = (0, utils_1.normalizeRelativePath)(path);
-        this.include = include.map(utils_1.normalizeRelativePath);
-        this.exclude = [this.localeDir, ...exclude.map(utils_1.normalizeRelativePath)];
+        this.path = normalizeRelativePath(path);
+        this.include = include.map(normalizeRelativePath);
+        this.exclude = [this.localeDir, ...exclude.map(normalizeRelativePath)];
         this.format = format;
         this.templateFile =
             templatePath ||
                 getTemplatePath(this.format.getTemplateExtension(), this.path);
     }
     getFilename(locale) {
-        return ((0, utils_1.replacePlaceholders)(this.path, { locale }) +
+        return (replacePlaceholders(this.path, { locale }) +
             this.format.getCatalogExtension());
     }
     async make(options) {
@@ -73,14 +71,14 @@ class Catalog {
     async collect(options = {}) {
         let paths = this.sourcePaths;
         if (options.files) {
-            options.files = options.files.map((p) => (0, utils_1.makePathRegexSafe)((0, normalize_path_1.default)(p, false)));
+            options.files = options.files.map((p) => makePathRegexSafe(normalize(p, false)));
             const regex = new RegExp(options.files.join("|"), "i");
-            paths = paths.filter((path) => regex.test((0, normalize_path_1.default)(path)));
+            paths = paths.filter((path) => regex.test(normalize(path)));
         }
         if (options.workerPool) {
-            return await (0, extractFromFiles_1.extractFromFilesWithWorkerPool)(options.workerPool, paths, this.config);
+            return await extractFromFilesWithWorkerPool(options.workerPool, paths, this.config);
         }
-        return await (0, extractFromFiles_1.extractFromFiles)(paths, this.config);
+        return await extractFromFiles(paths, this.config);
     }
     /*
      *
@@ -105,28 +103,33 @@ class Catalog {
     merge(prevCatalogs, nextCatalog, options) {
         return Object.fromEntries(Object.entries(prevCatalogs).map(([locale, prevCatalog]) => [
             locale,
-            (0, mergeCatalog_1.mergeCatalog)(prevCatalog, nextCatalog, this.config.sourceLocale === locale, options),
+            mergeCatalog(prevCatalog, nextCatalog, this.config.sourceLocale === locale, options),
         ]));
     }
     async getTranslations(locale, options) {
-        return await (0, getTranslationsForCatalog_1.getTranslationsForCatalog)(this, locale, options);
+        return await getTranslationsForCatalog(this, locale, options);
     }
     async write(locale, messages) {
         const filename = this.getFilename(locale);
-        const created = !fs_1.default.existsSync(filename);
+        const created = !fs.existsSync(filename);
         await this.format.write(filename, messages, locale);
         return [created, filename];
     }
     async writeTemplate(messages) {
         const filename = this.templateFile;
-        await this.format.write(filename, messages, undefined);
+        await this.format.write(filename, messages);
     }
     async read(locale) {
         return await this.format.read(this.getFilename(locale), locale);
     }
     async readAll(locales = this.locales) {
         const res = {};
-        await Promise.all(locales.map(async (locale) => (res[locale] = await this.read(locale))));
+        await Promise.all(locales.map(async (locale) => {
+            const catalog = await this.read(locale);
+            if (catalog) {
+                res[locale] = catalog;
+            }
+        }));
         // statement above will save locales in object in undetermined order
         // resort here to have keys order the same as in locales definition
         return this.locales.reduce((acc, locale) => {
@@ -135,21 +138,20 @@ class Catalog {
         }, {});
     }
     async readTemplate() {
-        const filename = this.templateFile;
-        return await this.format.read(filename, undefined);
+        return await this.format.read(this.templateFile, undefined);
     }
     get sourcePaths() {
         const includeGlobs = this.include.map((includePath) => {
-            const isDir = (0, utils_1.isDirectory)(includePath);
+            const isDir = isDirectory(includePath);
             /**
              * glob library results from absolute patterns such as /foo/* are mounted onto the root setting using path.join.
              * On windows, this will by default result in /foo/* matching C:\foo\bar.txt.
              */
             return isDir
-                ? (0, normalize_path_1.default)(path_1.default.resolve(process.cwd(), includePath === "/" ? "" : includePath, "**/*.*"))
+                ? normalize(path.resolve(process.cwd(), includePath === "/" ? "" : includePath, "**/*.*"))
                 : includePath;
         });
-        return (0, glob_1.globSync)(includeGlobs, { ignore: this.exclude, mark: true });
+        return globSync(includeGlobs, { exclude: this.exclude });
     }
     get localeDir() {
         const localePatternIndex = this.path.indexOf(LOCALE);
@@ -162,19 +164,18 @@ class Catalog {
         return this.config.locales;
     }
 }
-exports.Catalog = Catalog;
 function getTemplatePath(ext, path) {
     return path.replace(LOCALE_SUFFIX_RE, "messages" + ext);
 }
-function cleanObsolete(messages) {
+export function cleanObsolete(messages) {
     return Object.fromEntries(Object.entries(messages).filter(([, message]) => !message.obsolete));
 }
-function order(by, catalog) {
+export function order(by, catalog) {
     const orderByFn = typeof by === "function"
         ? by
         : {
             messageId: orderByMessageId,
-            message: exports.orderByMessage,
+            message: orderByMessage,
             origin: orderByOrigin,
         }[by];
     return Object.keys(catalog)
@@ -195,6 +196,9 @@ const orderByMessageId = (a, b) => {
     return a.messageId.localeCompare(b.messageId);
 };
 const orderByOrigin = (a, b) => {
+    if (!a.entry.origin || !b.entry.origin) {
+        return 0;
+    }
     function getFirstOrigin(entry) {
         const sortedOrigins = entry.origin.sort((a, b) => {
             if (a[0] < b[0])
@@ -217,7 +221,7 @@ const orderByOrigin = (a, b) => {
         return 1;
     return 0;
 };
-async function writeCompiled(path, locale, compiledCatalog, namespace) {
+export async function writeCompiled(path, locale, compiledCatalog, namespace) {
     let ext;
     switch (namespace) {
         case "es":
@@ -230,11 +234,11 @@ async function writeCompiled(path, locale, compiledCatalog, namespace) {
         default:
             ext = "js";
     }
-    const filename = `${(0, utils_1.replacePlaceholders)(path, { locale })}.${ext}`;
-    await (0, utils_1.writeFile)(filename, compiledCatalog);
+    const filename = `${replacePlaceholders(path, { locale })}.${ext}`;
+    await writeFile(filename, compiledCatalog);
     return filename;
 }
-const orderByMessage = (a, b) => {
+export const orderByMessage = (a, b) => {
     // hardcoded en-US locale to have consistent sorting
     // @see https://github.com/lingui/js-lingui/pull/1808
     const collator = new Intl.Collator("en-US");
@@ -244,4 +248,3 @@ const orderByMessage = (a, b) => {
     const bCtxt = b.entry.context || "";
     return collator.compare(aMsg, bMsg) || collator.compare(aCtxt, bCtxt);
 };
-exports.orderByMessage = orderByMessage;

package/dist/api/compile/compileLocale.d.ts

@@ -1,5 +1,5 @@
-import { Catalog } from "../catalog";
+import { Catalog } from "../catalog.js";
 import { LinguiConfigNormalized } from "@lingui/conf";
-import { CliCompileOptions } from "../../lingui-compile";
-import { Logger } from "../logger";
+import { CliCompileOptions } from "../../lingui-compile.js";
+import { Logger } from "../logger.js";
 export declare function compileLocale(catalogs: Catalog[], locale: string, options: CliCompileOptions, config: LinguiConfigNormalized, doMerge: boolean, logger: Logger): Promise<void>;

package/dist/api/compile/compileLocale.js

@@ -1,31 +1,25 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileLocale = compileLocale;
-const catalog_1 = require("../catalog");
-const picocolors_1 = __importDefault(require("picocolors"));
-const getCatalogs_1 = require("../catalog/getCatalogs");
-const ProgramExit_1 = require("../ProgramExit");
-const compile_1 = require("../compile");
-const normalize_path_1 = __importDefault(require("normalize-path"));
-const path_1 = __importDefault(require("path"));
-const messages_1 = require("../messages");
-const getTranslationsForCatalog_1 = require("../catalog/getTranslationsForCatalog");
-async function compileLocale(catalogs, locale, options, config, doMerge, logger) {
+import { writeCompiled } from "../catalog.js";
+import { styleText } from "node:util";
+import { getMergedCatalogPath } from "../catalog/getCatalogs.js";
+import { ProgramExit } from "../ProgramExit.js";
+import { createCompiledCatalog } from "../compile.js";
+import normalizePath from "normalize-path";
+import nodepath from "path";
+import { createCompilationErrorMessage } from "../messages.js";
+import { getTranslationsForCatalog } from "../catalog/getTranslationsForCatalog.js";
+export async function compileLocale(catalogs, locale, options, config, doMerge, logger) {
     let mergedCatalogs = {};
     for (const catalog of catalogs) {
-        const { messages, missing: missingMessages } = await (0, getTranslationsForCatalog_1.getTranslationsForCatalog)(catalog, locale, {
+        const { messages, missing: missingMessages } = await getTranslationsForCatalog(catalog, locale, {
             fallbackLocales: config.fallbackLocales,
             sourceLocale: config.sourceLocale,
         });
         if (!options.allowEmpty &&
             locale !== config.pseudoLocale &&
             missingMessages.length > 0) {
-            logger.error(picocolors_1.default.red(`Error: Failed to compile catalog for locale ${picocolors_1.default.bold(locale)}!`));
+            logger.error(styleText("red", `Error: Failed to compile catalog for locale ${styleText("bold", locale)}!`));
             if (options.verbose) {
-                logger.error(picocolors_1.default.red("Missing translations:"));
+                logger.error(styleText("red", "Missing translations:"));
                 missingMessages.forEach((missing) => {
                     const source = missing.source || missing.source === missing.id
                         ? `: (${missing.source})`
@@ -34,24 +28,24 @@ async function compileLocale(catalogs, locale, options, config, doMerge, logger)
                 });
             }
             else {
-                logger.error(picocolors_1.default.red(`Missing ${missingMessages.length} translation(s)`));
+                logger.error(styleText("red", `Missing ${missingMessages.length} translation(s)`));
             }
-            logger.error();
-            throw new ProgramExit_1.ProgramExit();
+            logger.error("");
+            throw new ProgramExit();
         }
         if (doMerge) {
-            mergedCatalogs = Object.assign(Object.assign({}, mergedCatalogs), messages);
+            mergedCatalogs = { ...mergedCatalogs, ...messages };
         }
         else {
             if (!(await compileAndWrite(locale, config, options, catalog.path, messages, logger))) {
-                throw new ProgramExit_1.ProgramExit();
+                throw new ProgramExit();
             }
         }
     }
     if (doMerge) {
-        const result = await compileAndWrite(locale, config, options, await (0, getCatalogs_1.getMergedCatalogPath)(config), mergedCatalogs, logger);
+        const result = await compileAndWrite(locale, config, options, await getMergedCatalogPath(config), mergedCatalogs, logger);
         if (!result) {
-            throw new ProgramExit_1.ProgramExit();
+            throw new ProgramExit();
         }
     }
 }
@@ -59,7 +53,7 @@ async function compileAndWrite(locale, config, options, writePath, messages, log
     const namespace = options.typescript
         ? "ts"
         : options.namespace || config.compileNamespace;
-    const { source: compiledCatalog, errors } = (0, compile_1.createCompiledCatalog)(locale, messages, {
+    const { source: compiledCatalog, errors } = createCompiledCatalog(locale, messages, {
         strict: false,
         namespace,
         outputPrefix: options.outputPrefix,
@@ -67,19 +61,20 @@ async function compileAndWrite(locale, config, options, writePath, messages, log
         compilerBabelOptions: config.compilerBabelOptions,
     });
     if (errors.length) {
-        let message = (0, messages_1.createCompilationErrorMessage)(locale, errors);
+        let message = createCompilationErrorMessage(locale, errors);
         if (options.failOnCompileError) {
             message += `These errors fail command execution because \`--strict\` option passed`;
-            logger.error(picocolors_1.default.red(message));
+            logger.error(styleText("red", message));
             return false;
         }
         else {
             message += `You can fail command execution on these errors by passing \`--strict\` option`;
-            logger.error(picocolors_1.default.red(message));
+            logger.error(styleText("red", message));
         }
     }
-    let compiledPath = await (0, catalog_1.writeCompiled)(writePath, locale, compiledCatalog, namespace);
-    compiledPath = (0, normalize_path_1.default)(path_1.default.relative(config.rootDir, compiledPath));
-    options.verbose && logger.error(picocolors_1.default.green(`${locale} ⇒ ${compiledPath}`));
+    let compiledPath = await writeCompiled(writePath, locale, compiledCatalog, namespace);
+    compiledPath = normalizePath(nodepath.relative(config.rootDir, compiledPath));
+    options.verbose &&
+        logger.error(styleText("green", `${locale} ⇒ ${compiledPath}`));
     return true;
 }

package/dist/api/compile.js

@@ -1,48 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCompiledCatalog = createCompiledCatalog;
-exports.compile = compile;
-const t = __importStar(require("@babel/types"));
-const generator_1 = __importDefault(require("@babel/generator"));
-const compileMessage_1 = require("@lingui/message-utils/compileMessage");
-const pseudoLocalize_1 = __importDefault(require("./pseudoLocalize"));
-function createCompiledCatalog(locale, messages, options) {
+import * as t from "@babel/types";
+import { generate } from "@babel/generator";
+import { compileMessageOrThrow, } from "@lingui/message-utils/compileMessage";
+import pseudoLocalize from "./pseudoLocalize.js";
+export function createCompiledCatalog(locale, messages, options) {
     const { strict = false, namespace = "cjs", pseudoLocale, compilerBabelOptions = {}, outputPrefix = "/*eslint-disable*/", } = options;
     const shouldPseudolocalize = locale === pseudoLocale;
     const errors = [];
@@ -69,9 +29,13 @@ function createCompiledCatalog(locale, messages, options) {
     const ast = buildExportStatement(
     //build JSON.parse(<compiledMessages>) statement
     t.callExpression(t.memberExpression(t.identifier("JSON"), t.identifier("parse")), [t.stringLiteral(JSON.stringify(compiledMessages))]), namespace);
-    const code = (0, generator_1.default)(ast, Object.assign({ minified: true, jsescOption: {
+    const code = generate(ast, {
+        minified: true,
+        jsescOption: {
             minimal: true,
-        } }, compilerBabelOptions)).code;
+        },
+        ...compilerBabelOptions,
+    }).code;
     return { source: `${outputPrefix}` + code, errors };
 }
 function buildExportStatement(expression, namespace) {
@@ -116,6 +80,6 @@ function buildExportStatement(expression, namespace) {
  * Compile string message into AST tree. Message format is parsed/compiled into
  * JS arrays, which are handled in client.
  */
-function compile(message, shouldPseudolocalize = false) {
-    return (0, compileMessage_1.compileMessageOrThrow)(message, (value) => shouldPseudolocalize ? (0, pseudoLocalize_1.default)(value) : value);
+export function compile(message, shouldPseudolocalize = false) {
+    return compileMessageOrThrow(message, (value) => shouldPseudolocalize ? pseudoLocalize(value) : value);
 }

package/dist/api/extractors/babel.d.ts

@@ -1,5 +1,5 @@
 import { ParserOptions } from "@babel/core";
-import { ExtractorType, LinguiConfig, ExtractedMessage, ExtractorCtx } from "@lingui/conf";
+import { ExtractorType, LinguiConfigNormalized, ExtractedMessage, ExtractorCtx } from "@lingui/conf";
 export declare const babelRe: RegExp;
 /**
  * @public
@@ -27,6 +27,6 @@ export declare const babelRe: RegExp;
  * ```
  */
 export declare function extractFromFileWithBabel(filename: string, code: string, onMessageExtracted: (msg: ExtractedMessage) => void, ctx: ExtractorCtx, parserOpts: ParserOptions, skipMacroPlugin?: boolean): Promise<void>;
-export declare function getBabelParserOptions(filename: string, parserOptions: LinguiConfig["extractorParserOptions"]): (import("@babel/parser").ParserPluginWithOptions | ("decimal" | "placeholders" | "asyncDoExpressions" | "asyncGenerators" | "bigInt" | "classPrivateMethods" | "classPrivateProperties" | "classProperties" | "classStaticBlock" | "decorators-legacy" | "deferredImportEvaluation" | "decoratorAutoAccessors" | "destructuringPrivate" | "doExpressions" | "dynamicImport" | "explicitResourceManagement" | "exportDefaultFrom" | "exportNamespaceFrom" | "flow" | "flowComments" | "functionBind" | "functionSent" | "importMeta" | "jsx" | "logicalAssignment" | "importAssertions" | "importReflection" | "moduleBlocks" | "moduleStringNames" | "nullishCoalescingOperator" | "numericSeparator" | "objectRestSpread" | "optionalCatchBinding" | "optionalChaining" | "partialApplication" | "privateIn" | "regexpUnicodeSets" | "sourcePhaseImports" | "throwExpressions" | "topLevelAwait" | "v8intrinsic" | "decorators" | "estree" | "importAttributes" | "moduleAttributes" | "optionalChainingAssign" | "pipelineOperator" | "recordAndTuple" | "typescript"))[];
+export declare function getBabelParserOptions(filename: string, parserOptions: LinguiConfigNormalized["extractorParserOptions"]): (import("@babel/parser").ParserPluginWithOptions | ("decimal" | "asyncDoExpressions" | "asyncGenerators" | "bigInt" | "classPrivateMethods" | "classPrivateProperties" | "classProperties" | "classStaticBlock" | "decorators-legacy" | "deferredImportEvaluation" | "decoratorAutoAccessors" | "destructuringPrivate" | "doExpressions" | "dynamicImport" | "explicitResourceManagement" | "exportDefaultFrom" | "exportNamespaceFrom" | "flow" | "flowComments" | "functionBind" | "functionSent" | "importMeta" | "jsx" | "logicalAssignment" | "importAssertions" | "importReflection" | "moduleBlocks" | "moduleStringNames" | "nullishCoalescingOperator" | "numericSeparator" | "objectRestSpread" | "optionalCatchBinding" | "optionalChaining" | "partialApplication" | "placeholders" | "privateIn" | "regexpUnicodeSets" | "sourcePhaseImports" | "throwExpressions" | "topLevelAwait" | "v8intrinsic" | "decorators" | "estree" | "importAttributes" | "moduleAttributes" | "optionalChainingAssign" | "pipelineOperator" | "recordAndTuple" | "typescript"))[];
 declare const extractor: ExtractorType;
 export default extractor;

package/dist/api/extractors/babel.js

@@ -1,20 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.babelRe = void 0;
-exports.extractFromFileWithBabel = extractFromFileWithBabel;
-exports.getBabelParserOptions = getBabelParserOptions;
-const core_1 = require("@babel/core");
-const babel_plugin_extract_messages_1 = __importDefault(require("@lingui/babel-plugin-extract-messages"));
-const babel_plugin_lingui_macro_1 = __importDefault(require("@lingui/babel-plugin-lingui-macro"));
-exports.babelRe = new RegExp("\\.(" +
-    [...core_1.DEFAULT_EXTENSIONS, ".ts", ".mts", ".cts", ".tsx"]
+import { DEFAULT_EXTENSIONS, transformAsync } from "@babel/core";
+import linguiExtractMessages from "@lingui/babel-plugin-extract-messages";
+import linguiMacroPlugin from "@lingui/babel-plugin-lingui-macro";
+export const babelRe = new RegExp("\\.(" +
+    [...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 inlineSourceMapsRE = new RegExp(/\/[/*][#@]\s+sourceMappingURL=data:application\/json;(?:charset[:=]utf-8;)?base64,([A-Za-z0-9+/=]+)/i);
+const globalInlineSourceMapsRE = new RegExp(inlineSourceMapsRE.source, "gi");
+const extractInlineSourceMap = (code) => {
+    let base64Data;
+    globalInlineSourceMapsRE.lastIndex = 0;
+    for (const match of code.matchAll(globalInlineSourceMapsRE)) {
+        base64Data = match[1];
+    }
+    if (!base64Data)
+        return null;
+    try {
+        const jsonString = Buffer.from(base64Data, "base64").toString("utf-8");
+        return JSON.parse(jsonString);
+    }
+    catch {
+        return null;
+    }
+};
 /**
  * Create a source mapper which could read original positions
  * from either inline sourcemaps or from external passed as `sourceMaps` argument.
@@ -25,33 +34,28 @@ const inlineSourceMapsRE = new RegExp(/\/[/*][#@]\s+sourceMappingURL=data:applic
  * @param sourceMaps Raw Sourcemaps object to mapping from. Check the https://github.com/mozilla/source-map#new-sourcemapconsumerrawsourcemap
  */
 async function createSourceMapper(code, sourceMaps) {
-    let sourceMapsConsumer;
-    if (sourceMaps) {
-        const { SourceMapConsumer } = await import("source-map");
-        sourceMapsConsumer = await new SourceMapConsumer(sourceMaps);
-    }
-    else if (code.search(inlineSourceMapsRE) != -1) {
-        const { SourceMapConsumer } = await import("source-map");
-        const { fromSource } = await import("convert-source-map");
-        const t = fromSource(code).toObject();
-        sourceMapsConsumer = await new SourceMapConsumer(t);
+    const map = sourceMaps ?? extractInlineSourceMap(code);
+    if (!map) {
+        return {
+            destroy: () => { },
+            originalPositionFor: (origin) => origin,
+        };
     }
+    const { SourceMapConsumer } = await import("source-map");
+    const sourceMapsConsumer = await new SourceMapConsumer(map);
     return {
-        destroy: () => {
-            if (sourceMapsConsumer) {
-                sourceMapsConsumer.destroy();
-            }
-        },
+        destroy: () => sourceMapsConsumer.destroy(),
         originalPositionFor: (origin) => {
-            if (!sourceMapsConsumer) {
-                return origin;
-            }
             const [_, line, column] = origin;
             const mappedPosition = sourceMapsConsumer.originalPositionFor({
                 line,
-                column,
+                column: column,
             });
-            return [mappedPosition.source, mappedPosition.line, mappedPosition.column];
+            return [
+                mappedPosition.source,
+                mappedPosition.line,
+                mappedPosition.column,
+            ];
         },
     };
 }
@@ -80,21 +84,21 @@ async function createSourceMapper(code, sourceMaps) {
  * }
  * ```
  */
-async function extractFromFileWithBabel(filename, code, onMessageExtracted, ctx, parserOpts, skipMacroPlugin = false) {
-    const mapper = await createSourceMapper(code, ctx === null || ctx === void 0 ? void 0 : ctx.sourceMaps);
-    await (0, core_1.transformAsync)(code, {
+export async function extractFromFileWithBabel(filename, code, onMessageExtracted, ctx, parserOpts, skipMacroPlugin = false) {
+    const mapper = await createSourceMapper(code, ctx?.sourceMaps);
+    await transformAsync(code, {
         // don't generate code
         code: false,
         babelrc: false,
         configFile: false,
         filename: filename,
-        inputSourceMap: ctx === null || ctx === void 0 ? void 0 : ctx.sourceMaps,
+        inputSourceMap: ctx?.sourceMaps,
         parserOpts,
         plugins: [
             ...(!skipMacroPlugin
                 ? [
                     [
-                        babel_plugin_lingui_macro_1.default,
+                        linguiMacroPlugin,
                         {
                             extract: true,
                             linguiConfig: ctx.linguiConfig,
@@ -103,10 +107,13 @@ async function extractFromFileWithBabel(filename, code, onMessageExtracted, ctx,
                 ]
                 : []),
             [
-                babel_plugin_extract_messages_1.default,
+                linguiExtractMessages,
                 {
                     onMessageExtracted: (msg) => {
-                        return onMessageExtracted(Object.assign(Object.assign({}, msg), { origin: mapper.originalPositionFor(msg.origin) }));
+                        return onMessageExtracted({
+                            ...msg,
+                            origin: mapper.originalPositionFor(msg.origin),
+                        });
                     },
                 },
             ],
@@ -114,7 +121,7 @@ async function extractFromFileWithBabel(filename, code, onMessageExtracted, ctx,
     });
     mapper.destroy();
 }
-function getBabelParserOptions(filename, parserOptions) {
+export function getBabelParserOptions(filename, parserOptions) {
     // https://babeljs.io/docs/en/babel-parser#latest-ecmascript-features
     const parserPlugins = [
         "importAttributes", // stage3
@@ -133,7 +140,7 @@ function getBabelParserOptions(filename, parserOptions) {
     }
     else {
         parserPlugins.push("decorators");
-        if (parserOptions === null || parserOptions === void 0 ? void 0 : parserOptions.flow) {
+        if (parserOptions?.flow) {
             parserPlugins.push("flow");
         }
     }
@@ -144,7 +151,7 @@ function getBabelParserOptions(filename, parserOptions) {
 }
 const extractor = {
     match(filename) {
-        return exports.babelRe.test(filename);
+        return babelRe.test(filename);
     },
     async extract(filename, code, onMessageExtracted, ctx) {
         const parserOptions = ctx.linguiConfig.extractorParserOptions;
@@ -153,4 +160,4 @@ const extractor = {
         });
     },
 };
-exports.default = extractor;
+export default extractor;

package/dist/api/extractors/index.js

@@ -1,20 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = extract;
-const promises_1 = __importDefault(require("fs/promises"));
-const babel_1 = __importDefault(require("./babel"));
-const DEFAULT_EXTRACTORS = [babel_1.default];
-async function extract(filename, onMessageExtracted, linguiConfig) {
-    var _a;
-    const extractorsToExtract = (_a = linguiConfig.extractors) !== null && _a !== void 0 ? _a : DEFAULT_EXTRACTORS;
+import fs from "fs/promises";
+import babel from "./babel.js";
+const DEFAULT_EXTRACTORS = [babel];
+export default async function extract(filename, onMessageExtracted, linguiConfig) {
+    const extractorsToExtract = linguiConfig.extractors ?? DEFAULT_EXTRACTORS;
     for (const ext of extractorsToExtract) {
         if (!ext.match(filename))
             continue;
         try {
-            const file = await promises_1.default.readFile(filename);
+            const file = await fs.readFile(filename);
             await ext.extract(filename, file.toString(), onMessageExtracted, {
                 linguiConfig,
             });

package/dist/api/formats/formatterWrapper.d.ts

@@ -5,6 +5,6 @@ export declare class FormatterWrapper {
     constructor(f: CatalogFormatter, sourceLocale: string);
     getCatalogExtension(): string;
     getTemplateExtension(): string;
-    write(filename: string, catalog: CatalogType, locale: string): Promise<void>;
-    read(filename: string, locale: string): Promise<CatalogType | null>;
+    write(filename: string, catalog: CatalogType, locale?: string): Promise<void>;
+    read(filename: string, locale: string | undefined): Promise<CatalogType | undefined>;
 }