@gtkx/cli 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/i18n/source-messages.js

@@ -33,6 +33,62 @@ const STATIC_KEY_WRAPPER_TYPES = new Set([
     "TSTypeAssertion",
     "TSNonNullExpression",
 ]);
+class SourceExtractionError extends Error {
+}
+const sourceErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const projectSourcePath = (root, path) => {
+    const absolute = isAbsolute(path) ? resolve(path) : resolve(root, path);
+    return toPosixPath(isPathInside(root, absolute) ? relative(root, absolute) : path);
+};
+const sourceExtractionError = (root, path, point, error) => {
+    if (error instanceof SourceExtractionError) {
+        return error;
+    }
+    const file = projectSourcePath(root, path);
+    const location = point === null
+        ? file
+        : `${file}:${String(point.line)}:${String(point.column + 1)}`;
+    return new SourceExtractionError(`${location}: ${sourceErrorMessage(error)}`, { cause: error });
+};
+const locatablePoint = (node) => {
+    const location = node.loc?.start;
+    return location === undefined ? null : { column: location.column, line: location.line };
+};
+const isSourcePoint = (value) => typeof value === "object" &&
+    value !== null &&
+    "column" in value &&
+    typeof value.column === "number" &&
+    "line" in value &&
+    typeof value.line === "number";
+const errorSourcePoint = (error) => {
+    if (typeof error !== "object" || error === null) {
+        return null;
+    }
+    if ("loc" in error && isSourcePoint(error.loc)) {
+        return error.loc;
+    }
+    return "location" in error && isSourcePoint(error.location) ? error.location : null;
+};
+const atSourceNode = (root, path, node, operation) => {
+    try {
+        return operation();
+    }
+    catch (error) {
+        throw sourceExtractionError(root, path, locatablePoint(node), error);
+    }
+};
+const atExtractedLocation = (root, locations, operation) => {
+    const location = locations.find((candidate) => candidate.line !== undefined && candidate.column !== undefined);
+    if (location?.line === undefined || location.column === undefined) {
+        return operation();
+    }
+    try {
+        return operation();
+    }
+    catch (error) {
+        throw sourceExtractionError(root, location.file, { column: location.column, line: location.line }, error);
+    }
+};
 const quietLogger = () => {
     const reports = [];
     return {
@@ -121,10 +177,10 @@ const expandedPlural = (entry) => {
         },
     };
 };
-const groupedPlurals = (entries) => {
+const groupedPlurals = (root, entries) => {
     const groups = new Map();
     for (const entry of entries) {
-        const { baseKey, variant } = expandedPlural(entry);
+        const { baseKey, variant } = atExtractedLocation(root, entry.locations ?? [], () => expandedPlural(entry));
         const namespace = namespaceFor(entry);
         const key = `${namespace}\0${baseKey}`;
         const group = groups.get(key) ?? { baseKey, namespace, variants: [] };
@@ -163,17 +219,19 @@ const pluralMessage = ({ baseKey, namespace, variants }) => {
         sourceKey: msgid,
     };
 };
-const pluralMessages = (entries) => groupedPlurals(entries).map((group) => pluralMessage(group));
+const pluralMessages = (root, entries) => groupedPlurals(root, entries).map((group) => atExtractedLocation(root, group.variants.flatMap((variant) => variant.locations), () => pluralMessage(group)));
 const assertCardinal = (entry) => {
     if (entry.isOrdinal === true) {
         throw new Error("GNU gettext catalogs do not support i18next ordinal plurals");
     }
 };
-const sourceMessages = (entries) => {
+const sourceMessages = (root, entries) => {
     const points = [];
     const plurals = [];
     for (const entry of entries) {
-        assertCardinal(entry);
+        atExtractedLocation(root, entry.locations ?? [], () => {
+            assertCardinal(entry);
+        });
         if (entry.isExpandedPlural === true) {
             plurals.push(entry);
             continue;
@@ -183,7 +241,10 @@ const sourceMessages = (entries) => {
         }
         points.push(entry);
     }
-    return [...points.map((entry) => pointMessage(entry)), ...pluralMessages(plurals)];
+    return [
+        ...points.map((entry) => atExtractedLocation(root, entry.locations ?? [], () => pointMessage(entry))),
+        ...pluralMessages(root, plurals),
+    ];
 };
 const compareMessages = (left, right) => left.namespace.localeCompare(right.namespace) ||
     (left.context ?? "").localeCompare(right.context ?? "") ||
@@ -497,13 +558,12 @@ const registerSourceMask = (node, references) => {
 };
 const sourceLocationKey = (line, column) => `${String(line)}:${String(column)}`;
 const sourcePoint = (node) => {
-    const location = node.loc?.start;
-    return location === undefined ? null : { column: location.column, line: location.line };
+    return locatablePoint(node);
 };
 const registerSourceLocation = (node, references) => {
     const point = sourcePoint(node);
     if (point !== null) {
-        references.locations.add(sourceLocationKey(point.line, point.column));
+        references.locations.set(sourceLocationKey(point.line, point.column), point);
     }
     return point;
 };
@@ -603,6 +663,9 @@ const registerCallReference = (callPath, references, keyPrefix) => {
     references.calls.add(nodeStart(callPath));
     const firstArgument = callPath.node.arguments[0];
     const point = registerSourceLocation(firstArgument ?? callPath.node, references);
+    if (point !== null) {
+        references.sourcePoints.set(nodeStart(callPath), point);
+    }
     registerEntryLocation(extractedEntryKey(callPath.node, keyPrefix), point, references);
 };
 const parserPlugins = (lang) => [
@@ -610,6 +673,21 @@ const parserPlugins = (lang) => [
     ...(lang === "ts" || lang === "tsx" ? ["typescript"] : []),
     ...(lang === "jsx" || lang === "tsx" ? ["jsx"] : []),
 ];
+const parseTranslationReferences = (root, path, source, lang) => {
+    try {
+        return parseBabelSync(source, {
+            ast: true,
+            babelrc: false,
+            configFile: false,
+            filename: projectSourcePath(root, path),
+            parserOpts: { createParenthesizedExpressions: true, plugins: parserPlugins(lang) },
+            sourceType: "module",
+        });
+    }
+    catch (error) {
+        throw sourceExtractionError(root, path, errorSourcePoint(error), error);
+    }
+};
 const registerIdentifierTranslationCall = (callPath, callee, references) => {
     if (!callee.isIdentifier()) {
         return;
@@ -680,6 +758,14 @@ const registerUnrecognizedElementMasks = (elementPath, name, references) => {
         registerSourceMask(closingName, references);
     }
 };
+const registerElementReference = (elementPath, references) => {
+    const start = nodeStart(elementPath);
+    const point = registerSourceLocation(elementPath.node, references);
+    references.elements.add(start);
+    if (point !== null) {
+        references.sourcePoints.set(start, point);
+    }
+};
 const registerTranslationElement = (elementPath, references) => {
     const name = elementPath.get("name");
     if (!name.isJSXIdentifier()) {
@@ -690,8 +776,7 @@ const registerTranslationElement = (elementPath, references) => {
         throw new Error("Translation components must use their imported names");
     }
     if (kind === "canonical") {
-        references.elements.add(nodeStart(elementPath));
-        registerSourceLocation(elementPath.node, references);
+        registerElementReference(elementPath, references);
     }
     else if (TRANS_ELEMENTS.has(name.node.name)) {
         registerUnrecognizedElementMasks(elementPath, name, references);
@@ -705,15 +790,8 @@ const maskUnrecognizedTranslations = (source, references) => {
     }
     return masked;
 };
-const translationReferences = (path, source, lang) => {
-    const parsed = parseBabelSync(source, {
-        ast: true,
-        babelrc: false,
-        configFile: false,
-        filename: path,
-        parserOpts: { createParenthesizedExpressions: true, plugins: parserPlugins(lang) },
-        sourceType: "module",
-    });
+const translationReferences = (root, path, source, lang) => {
+    const parsed = parseTranslationReferences(root, path, source, lang);
     if (parsed === null) {
         throw new Error(`Translation extraction could not parse ${path}`);
     }
@@ -721,21 +799,30 @@ const translationReferences = (path, source, lang) => {
         calls: new Set(),
         elements: new Set(),
         entryLocations: new Map(),
-        locations: new Set(),
+        locations: new Map(),
         masks: [],
+        sourcePoints: new Map(),
     };
     traverse(parsed, {
         CallExpression(callPath) {
-            registerTranslationCall(callPath, references);
+            atSourceNode(root, path, callPath.node, () => {
+                registerTranslationCall(callPath, references);
+            });
         },
         JSXOpeningElement(elementPath) {
-            registerTranslationElement(elementPath, references);
+            atSourceNode(root, path, elementPath.node, () => {
+                registerTranslationElement(elementPath, references);
+            });
         },
         OptionalCallExpression(callPath) {
-            assertSupportedOptionalCall(callPath);
+            atSourceNode(root, path, callPath.node, () => {
+                assertSupportedOptionalCall(callPath);
+            });
         },
         TaggedTemplateExpression(tagPath) {
-            assertUnsupportedTranslationTag(tagPath);
+            atSourceNode(root, path, tagPath.node, () => {
+                assertUnsupportedTranslationTag(tagPath);
+            });
         },
     });
     return references;
@@ -799,19 +886,42 @@ const assertSupportedTransElement = (node, references) => {
         assertSupportedTransAttribute(attribute);
     }
 };
-const assertSupportedTranslationSyntax = (path, source) => {
+const assertSupportedTranslationSyntax = (root, path, source) => {
     const lang = sourceLanguage(path);
     if (lang === undefined) {
-        return { calls: new Set(), elements: new Set(), entryLocations: new Map(), locations: new Set(), masks: [] };
+        return {
+            calls: new Set(),
+            elements: new Set(),
+            entryLocations: new Map(),
+            locations: new Map(),
+            masks: [],
+            sourcePoints: new Map(),
+        };
+    }
+    let parsed;
+    try {
+        parsed = parseSync(projectSourcePath(root, path), source, { lang });
+    }
+    catch (error) {
+        throw sourceExtractionError(root, path, errorSourcePoint(error), error);
     }
-    const parsed = parseSync(path, source, { lang });
-    const references = translationReferences(path, source, lang);
+    const references = translationReferences(root, path, source, lang);
     new Visitor({
         CallExpression(node) {
-            assertSupportedTranslationCall(node, references);
+            try {
+                assertSupportedTranslationCall(node, references);
+            }
+            catch (error) {
+                throw sourceExtractionError(root, path, references.sourcePoints.get(node.start) ?? null, error);
+            }
         },
         JSXOpeningElement(node) {
-            assertSupportedTransElement(node, references);
+            try {
+                assertSupportedTransElement(node, references);
+            }
+            catch (error) {
+                throw sourceExtractionError(root, path, references.sourcePoints.get(node.start) ?? null, error);
+            }
         },
     }).visit(parsed.program);
     return references;
@@ -997,12 +1107,20 @@ const extractedSourcePoints = (root, entries) => {
     }
     return points;
 };
-const hasMissingSourcePoint = (file, references, extracted) => references.locations.values().some((location) => !extracted.has(`${file}\0${location}`));
+const missingSourcePoint = (file, references, extracted) => {
+    for (const [location, point] of references.locations) {
+        if (!extracted.has(`${file}\0${location}`)) {
+            return point;
+        }
+    }
+    return null;
+};
 const assertAllReferencesExtracted = (root, references, entries) => {
     const extracted = extractedSourcePoints(root, entries);
     for (const [file, sourceReferences] of references) {
-        if (hasMissingSourcePoint(file, sourceReferences, extracted)) {
-            throw new Error("A translation expression could not be extracted safely");
+        const point = missingSourcePoint(file, sourceReferences, extracted);
+        if (point !== null) {
+            throw sourceExtractionError(root, file, point, new Error("A translation expression could not be extracted safely"));
         }
     }
 };
@@ -1014,7 +1132,7 @@ const findSourceMessages = async (root, sourceFiles) => {
     const sources = new Map(sourceFiles.map((file) => [file, readFileSync(file, "utf8")]));
     const references = new Map();
     for (const [file, source] of sources) {
-        references.set(file, assertSupportedTranslationSyntax(file, source));
+        references.set(file, assertSupportedTranslationSyntax(root, file, source));
     }
     let extracted;
     const { logger, reports } = quietLogger();
@@ -1042,7 +1160,7 @@ const findSourceMessages = async (root, sourceFiles) => {
     if (extracted === undefined || reports.length > 0 || result.hasErrors) {
         throw new Error(reports.join("\n") || "i18next extraction failed");
     }
-    return sourceMessages(extracted.values().toArray())
+    return sourceMessages(root, extracted.values().toArray())
         .map((message) => inferLocations(message, sources))
         .toSorted(compareMessages);
 };