@effect/language-service 0.47.2 → 0.48.0

package/README.md

@@ -296,6 +296,10 @@ If the filename and the class identifier are the same, they won't be repeated, b
 
 The skipLeadingPath array can contain a set of prefixes to remove from the subpath part of the path. By default "src/" is removed for example.
 
+### Pattern: default-hashed
+
+If you are concerned potentially showing service names in builds, this pattern is the same as default; but the string will be then hashed.
+
 ### Pattern: package-identifier
 
 This pattern uses the package name + identifier. This usually works great if you have a flat structure, with one file per service/error.

package/cli.js

@@ -31206,7 +31206,7 @@ function parseKeyPatterns(patterns) {
     if (!isObject(entry)) continue;
     result.push({
       target: hasProperty(entry, "target") && isString(entry.target) && ["service", "error", "custom"].includes(entry.target.toLowerCase()) ? entry.target.toLowerCase() : "service",
-      pattern: hasProperty(entry, "pattern") && isString(entry.pattern) && ["package-identifier", "default"].includes(entry.pattern.toLowerCase()) ? entry.pattern.toLowerCase() : "default",
+      pattern: hasProperty(entry, "pattern") && isString(entry.pattern) && ["package-identifier", "default", "default-hashed"].includes(entry.pattern.toLowerCase()) ? entry.pattern.toLowerCase() : "default",
       skipLeadingPath: hasProperty(entry, "skipLeadingPath") && isArray(entry.skipLeadingPath) && entry.skipLeadingPath.every(isString) ? entry.skipLeadingPath : ["src/"]
     });
   }
@@ -31570,10 +31570,10 @@ var TypeCheckerUtils = Tag4("TypeCheckerUtils");
 var nanoLayer2 = (fa) => pipe(
   service2(TypeScriptApi),
   flatMap18(
-    (ts) => flatMap18(service2(TypeCheckerApi), (typeChecker) => pipe(fa, provideService7(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker))))
+    (ts) => flatMap18(service2(TypeCheckerApi), (typeChecker) => flatMap18(service2(TypeScriptUtils), (typeScriptUtils) => pipe(fa, provideService7(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker, typeScriptUtils)))))
   )
 );
-function makeTypeCheckerUtils(ts, typeChecker) {
+function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   function isUnion4(type2) {
     return !!(type2.flags & ts.TypeFlags.Union);
   }
@@ -31813,6 +31813,78 @@ function makeTypeCheckerUtils(ts, typeChecker) {
     expectedAndRealTypeCache.set(sourceFile, result);
     return result;
   };
+  function typeToSimplifiedTypeNode(type2, enclosingNode, flags) {
+    return typeToSimplifiedTypeNodeWorker(type2, enclosingNode, flags, 0);
+  }
+  function typeToSimplifiedTypeNodeWorker(type2, enclosingNode, flags, depth) {
+    const fallbackStandard = () => {
+      const typeNode = typeChecker.typeToTypeNode(type2, enclosingNode, flags);
+      if (!typeNode) return void 0;
+      return tsUtils.simplifyTypeNode(typeNode);
+    };
+    if (depth > 20) return fallbackStandard();
+    const members = unrollUnionMembers(type2);
+    if (members.length > 1 && !(type2.flags & ts.TypeFlags.Boolean)) {
+      const typeNodes = [];
+      members.sort(deterministicTypeOrder);
+      for (const member of members) {
+        const memberNode = typeToSimplifiedTypeNodeWorker(member, enclosingNode, flags, depth + 1);
+        if (!memberNode) return fallbackStandard();
+        typeNodes.push(memberNode);
+      }
+      return tsUtils.simplifyTypeNode(ts.factory.createUnionTypeNode(typeNodes));
+    }
+    if (type2.flags & ts.TypeFlags.Intersection) {
+      const intersectionType = type2;
+      const typeNodes = [];
+      for (const member of intersectionType.types) {
+        const memberNode = typeToSimplifiedTypeNodeWorker(member, enclosingNode, flags, depth + 1);
+        if (!memberNode) return fallbackStandard();
+        typeNodes.push(memberNode);
+      }
+      return tsUtils.simplifyTypeNode(ts.factory.createIntersectionTypeNode(typeNodes));
+    }
+    if (type2.flags & ts.TypeFlags.Object && type2.objectFlags & ts.ObjectFlags.Reference) {
+      const typeReference = type2;
+      const standard2 = fallbackStandard();
+      if (!standard2) return void 0;
+      if (!ts.isTypeReferenceNode(standard2)) return standard2;
+      if (typeReference.target.typeParameters?.length !== typeReference.typeArguments?.length) return standard2;
+      if (standard2.typeArguments?.length !== typeReference.typeArguments?.length) return standard2;
+      const typeParametersCount = (typeReference.target.typeParameters || []).length;
+      for (let i = typeParametersCount - 1; i >= 0; i--) {
+        const typeParameter = typeReference.target.typeParameters[i];
+        const typeArgument = typeReference.typeArguments[i];
+        const defaultType = typeChecker.getDefaultFromTypeParameter(typeParameter);
+        if (defaultType !== typeArgument || i === 0) {
+          return tsUtils.simplifyTypeNode(ts.factory.updateTypeReferenceNode(
+            standard2,
+            standard2.typeName,
+            ts.factory.createNodeArray((standard2.typeArguments || []).slice(0, Math.min(typeParametersCount, i + 1)))
+          ));
+        }
+      }
+      return standard2;
+    }
+    if (type2.flags & ts.TypeFlags.Object) {
+      const standard2 = fallbackStandard();
+      if (!standard2) return void 0;
+      if (!ts.isFunctionTypeNode(standard2)) return standard2;
+      const signatures = typeChecker.getSignaturesOfType(type2, ts.SignatureKind.Call);
+      if (signatures.length !== 1) return standard2;
+      const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
+      if (!returnType) return standard2;
+      const returnTypeNode = typeToSimplifiedTypeNodeWorker(returnType, enclosingNode, flags, depth + 1);
+      if (!returnTypeNode) return standard2;
+      return tsUtils.simplifyTypeNode(ts.factory.updateFunctionTypeNode(
+        standard2,
+        standard2.typeParameters,
+        standard2.parameters,
+        returnTypeNode
+      ));
+    }
+    return fallbackStandard();
+  }
   return {
     isUnion: isUnion4,
     getTypeParameterAtPosition,
@@ -31821,7 +31893,8 @@ function makeTypeCheckerUtils(ts, typeChecker) {
     appendToUniqueTypesMap,
     deterministicTypeOrder,
     getInferredReturnType,
-    expectedAndRealType
+    expectedAndRealType,
+    typeToSimplifiedTypeNode
   };
 }
 
@@ -33000,7 +33073,8 @@ var makeKeyBuilder = fn2("KeyBuilder")(
         parts2 = parts2.map((part) => part.startsWith("/") ? part.slice(1) : part).map(
           (part) => part.endsWith("/") ? part.slice(0, -1) : part
         );
-        return parts2.filter((_) => String(_).trim().length > 0).join("/");
+        const fullKey = parts2.filter((_) => String(_).trim().length > 0).join("/");
+        return keyPattern.pattern === "default-hashed" ? cyrb53(fullKey) : fullKey;
       }
     }
     return {
@@ -34946,7 +35020,7 @@ var tryCatchInEffectGen = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isTryStatement(node)) {
+      if (ts.isTryStatement(node) && node.catchClause) {
         const generatorOrRegularFunction = ts.findAncestor(
           node,
           (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_) || ts.isFunctionLike(_)