@formatjs/cli 6.7.0 → 6.7.2

package/bin/formatjs

@@ -18547,9 +18547,9 @@ var init_compile_folder = __esm({
   }
 });
 
-// node_modules/.aspect_rules_js/typescript@5.8.2/node_modules/typescript/lib/typescript.js
+// node_modules/.aspect_rules_js/typescript@5.8.3/node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS({
-  "node_modules/.aspect_rules_js/typescript@5.8.2/node_modules/typescript/lib/typescript.js"(exports, module2) {
+  "node_modules/.aspect_rules_js/typescript@5.8.3/node_modules/typescript/lib/typescript.js"(exports, module2) {
     var ts2 = {};
     ((module3) => {
       "use strict";
@@ -20819,7 +20819,7 @@ var require_typescript = __commonJS({
       });
       module3.exports = __toCommonJS2(typescript_exports);
       var versionMajorMinor = "5.8";
-      var version = "5.8.2";
+      var version = "5.8.3";
       var Comparison = ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -77836,10 +77836,11 @@ ${lanes.join("\n")}
             serializeExistingTypeNode(context, typeNode, addUndefined) {
               return serializeExistingTypeNode(context, typeNode, !!addUndefined);
             },
-            serializeReturnTypeForSignature(syntacticContext, signatureDeclaration) {
+            serializeReturnTypeForSignature(syntacticContext, signatureDeclaration, symbol) {
               const context = syntacticContext;
               const signature = getSignatureFromDeclaration(signatureDeclaration);
-              const returnType = context.enclosingSymbolTypes.get(getSymbolId(getSymbolOfDeclaration(signatureDeclaration))) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
+              symbol ?? (symbol = getSymbolOfDeclaration(signatureDeclaration));
+              const returnType = context.enclosingSymbolTypes.get(getSymbolId(symbol)) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
               return serializeInferredReturnTypeForSignature(context, signature, returnType);
             },
             serializeTypeOfExpression(syntacticContext, expr) {
@@ -77853,7 +77854,7 @@ ${lanes.join("\n")}
               symbol ?? (symbol = getSymbolOfDeclaration(declaration));
               let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol));
               if (type === void 0) {
-                type = symbol && !(symbol.flags & (2048 | 131072)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
+                type = symbol.flags & 98304 && declaration.kind === 178 ? instantiateType(getWriteTypeOfSymbol(symbol), context.mapper) : symbol && !(symbol.flags & (2048 | 131072)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
               }
               const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
               if (addUndefinedForParameter) {
@@ -77920,6 +77921,7 @@ ${lanes.join("\n")}
               const context = syntacticContext;
               if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
                 let name = lit.text;
+                const originalName = name;
                 const nodeSymbol = getNodeLinks(parent2).resolvedSymbol;
                 const meaning = parent2.isTypeOf ? 111551 : 788968;
                 const parentSymbol = nodeSymbol && isSymbolAccessible(
@@ -77949,7 +77951,9 @@ ${lanes.join("\n")}
                     context.tracker.reportLikelyUnsafeImportRequiredError(name);
                   }
                 }
-                return name;
+                if (name !== originalName) {
+                  return name;
+                }
               }
             },
             canReuseTypeNode(context, typeNode) {
@@ -79139,6 +79143,7 @@ ${lanes.join("\n")}
             if (propertySymbol.flags & 98304) {
               const writeType = getWriteTypeOfSymbol(propertySymbol);
               if (propertyType !== writeType && !isErrorType(propertyType) && !isErrorType(writeType)) {
+                const symbolMapper = getSymbolLinks(propertySymbol).mapper;
                 const getterDeclaration = getDeclarationOfKind(
                   propertySymbol,
                   177
@@ -79148,7 +79153,7 @@ ${lanes.join("\n")}
                 typeElements.push(
                   setCommentRange2(
                     context,
-                    signatureToSignatureDeclarationHelper(getterSignature, 177, context, { name: propertyName }),
+                    signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(getterSignature, symbolMapper) : getterSignature, 177, context, { name: propertyName }),
                     getterDeclaration
                   )
                 );
@@ -79161,7 +79166,7 @@ ${lanes.join("\n")}
                 typeElements.push(
                   setCommentRange2(
                     context,
-                    signatureToSignatureDeclarationHelper(setterSignature, 178, context, { name: propertyName }),
+                    signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(setterSignature, symbolMapper) : setterSignature, 178, context, { name: propertyName }),
                     setterDeclaration
                   )
                 );
@@ -80436,13 +80441,13 @@ ${lanes.join("\n")}
             const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
             const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
             if (decl) {
+              const restore = addSymbolTypeToContext(context, symbol, type);
               if (isAccessor(decl)) {
                 result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
               } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608)) {
-                const restore = addSymbolTypeToContext(context, symbol, type);
                 result = syntacticNodeBuilder.serializeTypeOfDeclaration(decl, symbol, context);
-                restore();
               }
+              restore();
             }
             if (!result) {
               if (addUndefinedForParameter) {
@@ -80615,10 +80620,7 @@ ${lanes.join("\n")}
                 /*context*/
                 void 0
               );
-              if (updated !== node2) {
-                setTextRange2(context, updated, node2);
-              }
-              return updated;
+              return setTextRange2(context, updated, node2);
             }
           }
           function serializeTypeName(context, node, isTypeOf, typeArguments) {
@@ -106321,6 +106323,11 @@ ${lanes.join("\n")}
             ])) {
               grammarErrorOnNode(node, Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead);
             }
+            if (compilerOptions.erasableSyntaxOnly) {
+              const start = skipTrivia(file.text, node.pos);
+              const end = node.expression.pos;
+              diagnostics.add(createFileDiagnostic(file, start, end - start, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled));
+            }
           }
           return checkAssertionWorker(node, checkMode);
         }
@@ -165775,9 +165782,11 @@ ${lanes.join("\n")}
               if (!resolver.canReuseTypeNode(context, node)) {
                 return resolver.serializeExistingTypeNode(context, node);
               }
+              const specifier = rewriteModuleSpecifier2(node, node.argument.literal);
+              const literal = specifier === node.argument.literal ? reuseNode(context, node.argument.literal) : specifier;
               return factory.updateImportTypeNode(
                 node,
-                factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)),
+                literal === node.argument.literal ? reuseNode(context, node.argument) : factory.createLiteralTypeNode(literal),
                 visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
                 visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
                 visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
@@ -165939,10 +165948,7 @@ ${lanes.join("\n")}
             }
             function rewriteModuleSpecifier2(parent2, lit) {
               const newName = resolver.getModuleSpecifierOverride(context, parent2, lit);
-              if (newName) {
-                return setOriginalNode(factory.createStringLiteral(newName), lit);
-              }
-              return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
+              return newName ? setOriginalNode(factory.createStringLiteral(newName), lit) : lit;
             }
           }
         }
@@ -166118,12 +166124,7 @@ ${lanes.join("\n")}
             return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context));
           }
           if (accessorDeclarations.getAccessor) {
-            return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(
-              accessorDeclarations.getAccessor,
-              /*symbol*/
-              void 0,
-              context
-            ));
+            return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(accessorDeclarations.getAccessor, symbol, context));
           }
           return void 0;
         }
@@ -166242,7 +166243,7 @@ ${lanes.join("\n")}
             /* AnyKeyword */
           );
         }
-        function inferReturnTypeOfSignatureSignature(node, context, reportFallback) {
+        function inferReturnTypeOfSignatureSignature(node, context, symbol, reportFallback) {
           if (reportFallback) {
             context.tracker.reportInferenceFallback(node);
           }
@@ -166252,7 +166253,7 @@ ${lanes.join("\n")}
               /* AnyKeyword */
             );
           }
-          return resolver.serializeReturnTypeForSignature(context, node) ?? factory.createKeywordTypeNode(
+          return resolver.serializeReturnTypeForSignature(context, node, symbol) ?? factory.createKeywordTypeNode(
             133
             /* AnyKeyword */
           );
@@ -166567,18 +166568,17 @@ ${lanes.join("\n")}
           );
         }
         function reuseTypeParameters(typeParameters, context) {
-          return typeParameters == null ? void 0 : typeParameters.map(
-            (tp) => {
-              var _a;
-              return factory.updateTypeParameterDeclaration(
-                tp,
-                (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
-                reuseNode(context, tp.name),
-                serializeExistingTypeNodeWithFallback(tp.constraint, context),
-                serializeExistingTypeNodeWithFallback(tp.default, context)
-              );
-            }
-          );
+          return typeParameters == null ? void 0 : typeParameters.map((tp) => {
+            var _a;
+            const { node: tpName } = resolver.trackExistingEntityName(context, tp.name);
+            return factory.updateTypeParameterDeclaration(
+              tp,
+              (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
+              tpName,
+              serializeExistingTypeNodeWithFallback(tp.constraint, context),
+              serializeExistingTypeNodeWithFallback(tp.default, context)
+            );
+          });
         }
         function typeFromObjectLiteralMethod(method, name, context, isConstContext) {
           const returnType = createReturnFromSignature(
@@ -166733,7 +166733,7 @@ ${lanes.join("\n")}
           } else if (isValueSignatureDeclaration(fn)) {
             returnType = typeFromSingleReturnExpression(fn, context);
           }
-          return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, reportFallback && returnType.reportFallback && !returnTypeNode);
+          return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, symbol, reportFallback && returnType.reportFallback && !returnTypeNode);
         }
         function typeFromSingleReturnExpression(declaration, context) {
           let candidateExpr;
@@ -230184,6 +230184,22 @@ var require_transform = __commonJS({
                 msg.description = initializer.text;
                 break;
             }
+          } else if (ts2.isTaggedTemplateExpression(initializer)) {
+            const { template } = initializer;
+            if (!ts2.isNoSubstitutionTemplateLiteral(template)) {
+              throw new Error("Tagged template expression must be no substitution");
+            }
+            switch (name.text) {
+              case "id":
+                msg.id = template.text;
+                break;
+              case "defaultMessage":
+                msg.defaultMessage = template.text;
+                break;
+              case "description":
+                msg.description = template.text;
+                break;
+            }
           } else if (ts2.isJsxExpression(initializer) && initializer.expression) {
             if (ts2.isStringLiteral(initializer.expression)) {
               switch (name.text) {
@@ -230212,6 +230228,22 @@ var require_transform = __commonJS({
                   msg.description = expression.text;
                   break;
               }
+            } else if (ts2.isTaggedTemplateExpression(initializer.expression)) {
+              const { expression: { template } } = initializer;
+              if (!ts2.isNoSubstitutionTemplateLiteral(template)) {
+                throw new Error("Tagged template expression must be no substitution");
+              }
+              switch (name.text) {
+                case "id":
+                  msg.id = template.text;
+                  break;
+                case "defaultMessage":
+                  msg.defaultMessage = template.text;
+                  break;
+                case "description":
+                  msg.description = template.text;
+                  break;
+              }
             } else if (ts2.isBinaryExpression(initializer.expression)) {
               const { expression } = initializer;
               const [result, isStatic] = evaluateStringConcat(ts2, expression);
@@ -231194,7 +231226,7 @@ sentences are not translator-friendly.`
       debug("Reading inFile:", cmdObj.inFile);
       const inFile = (0, import_fs_extra5.readFileSync)(cmdObj.inFile, "utf8");
       files.push(
-        ...inFile.split("\n").filter(Boolean).map((f) => (0, import_path4.resolve)(f))
+        ...inFile.split(/\n|\s+/).filter(Boolean).map((f) => (0, import_path4.resolve)(f))
       );
     }
     debug("Files to extract:", files);

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "@formatjs/cli",
   "description": "A CLI for formatjs.",
-  "version": "6.7.0",
+  "version": "6.7.2",
   "license": "MIT",
   "author": "Linjie Ding <linjie@airtable.com>",
   "engines": {
     "node": ">= 16"
   },
   "devDependencies": {
-    "@formatjs/cli-lib": "7.4.0"
+    "@formatjs/cli-lib": "7.4.2"
   },
   "peerDependencies": {
-    "@glimmer/env": "^0.1.7",
-    "@glimmer/reference": "^0.94.0",
     "@glimmer/syntax": "^0.94.9",
-    "@glimmer/validator": "^0.94.0",
     "@vue/compiler-core": "^3.5.12",
     "content-tag": "^3.0.0",
     "ember-template-recast": "^6.1.5",