@effect/language-service 0.44.1 → 0.45.0

package/index.js

@@ -1210,14 +1210,19 @@ var defaults = {
     target: "service",
     pattern: "default",
     skipLeadingPath: ["src/"]
-  }]
+  }, {
+    target: "custom",
+    pattern: "default",
+    skipLeadingPath: ["src/"]
+  }],
+  extendedKeyDetection: false
 };
 function parseKeyPatterns(patterns) {
   const result = [];
   for (const entry of patterns) {
     if (!isObject(entry)) continue;
     result.push({
-      target: hasProperty(entry, "target") && isString(entry.target) && ["service", "error"].includes(entry.target.toLowerCase()) ? entry.target.toLowerCase() : "service",
+      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",
       skipLeadingPath: hasProperty(entry, "skipLeadingPath") && isArray(entry.skipLeadingPath) && entry.skipLeadingPath.every(isString) ? entry.skipLeadingPath : ["src/"]
     });
@@ -1243,7 +1248,8 @@ function parse(config) {
     topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
     renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
     noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal,
-    keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns
+    keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns,
+    extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection
   };
 }
 
@@ -4052,6 +4058,62 @@ var deterministicKeys = createDiagnostic({
   apply: fn("deterministicKeys.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeScriptUtils = yield* service(TypeScriptUtils);
+    const options = yield* service(LanguageServicePluginOptions);
+    const parseExtendsCustom = cachedBy(
+      fn("parseExtendsCustom")(function* (classDeclaration) {
+        if (!options.extendedKeyDetection) {
+          return yield* typeParserIssue("Extended key detection is disabled", void 0, classDeclaration);
+        }
+        if (!classDeclaration.name) {
+          return yield* typeParserIssue("Class has no name", void 0, classDeclaration);
+        }
+        if (!ts.isIdentifier(classDeclaration.name)) {
+          return yield* typeParserIssue("Class name is not an identifier", void 0, classDeclaration);
+        }
+        const heritageClauses = classDeclaration.heritageClauses;
+        if (!heritageClauses) {
+          return yield* typeParserIssue("Class has no heritage clauses", void 0, classDeclaration);
+        }
+        const nodeToVisit2 = [...classDeclaration.heritageClauses];
+        const appendNodeToVisit2 = (node) => {
+          nodeToVisit2.push(node);
+          return void 0;
+        };
+        while (nodeToVisit2.length > 0) {
+          const node = nodeToVisit2.shift();
+          if (ts.isCallExpression(node)) {
+            for (let i = 0; i < node.arguments.length; i++) {
+              const arg = node.arguments[i];
+              if (!ts.isStringLiteral(arg)) continue;
+              const resolvedSignature = typeChecker.getResolvedSignature(node);
+              if (resolvedSignature) {
+                const parameter = resolvedSignature.parameters[i];
+                if (!parameter) continue;
+                if (parameter.declarations) {
+                  for (const declaration of parameter.declarations) {
+                    const parameterSourceFile = typeScriptUtils.getSourceFileOfNode(declaration);
+                    const paramText = parameterSourceFile.text.substring(declaration.pos, declaration.end);
+                    if (paramText.toLowerCase().includes("@effect-identifier")) {
+                      return { className: classDeclaration.name, keyStringLiteral: arg, target: "custom" };
+                    }
+                  }
+                }
+              }
+            }
+          }
+          ts.forEachChild(node, appendNodeToVisit2);
+        }
+        return yield* typeParserIssue(
+          "Class does not extend any custom pattern",
+          void 0,
+          classDeclaration
+        );
+      }),
+      "deterministicKeys.parseExtendsCustom",
+      (classDeclaration) => classDeclaration
+    );
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -4075,12 +4137,13 @@ var deterministicKeys = createDiagnostic({
               map5(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "error" }))
             )
           ),
+          orElse2(() => parseExtendsCustom(node)),
           orElse2(() => void_)
         );
         if (result && result.keyStringLiteral) {
-          const { className, keyStringLiteral } = result;
+          const { className, keyStringLiteral, target } = result;
           const classNameText = ts.idText(className);
-          const expectedKey = yield* createString(sourceFile, classNameText, result.target);
+          const expectedKey = yield* createString(sourceFile, classNameText, target);
           if (!expectedKey) continue;
           const actualIdentifier = keyStringLiteral.text;
           if (actualIdentifier !== expectedKey) {
@@ -5857,6 +5920,31 @@ var effectDiagnosticsComment = createCompletion({
   })
 });
 
+// src/completions/effectJsdocComment.ts
+var effectJsdocComment = createCompletion({
+  name: "effectJsdocComment",
+  apply: fn("effectJsdocComment")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const sourceText = sourceFile.text;
+    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match2 && match2.indices) {
+      const lastIndex = match2.indices[2][0];
+      const replacementSpan = {
+        start: lastIndex,
+        length: Math.max(0, position - lastIndex)
+      };
+      return [{
+        name: `@effect-identifier`,
+        kind: ts.ScriptElementKind.string,
+        insertText: "@effect-identifier",
+        isSnippet: true,
+        replacementSpan
+      }];
+    }
+    return [];
+  })
+});
+
 // src/completions/effectSchemaSelfInClasses.ts
 var effectSchemaSelfInClasses = createCompletion({
   name: "effectSchemaSelfInClasses",
@@ -6090,6 +6178,7 @@ var completions = [
   effectDataClasses,
   effectDiagnosticsComment,
   effectCodegensComment,
+  effectJsdocComment,
   durationInput,
   schemaBrand
 ];