@effect/language-service 0.42.0 → 0.43.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.42.0",
+  "version": "0.43.1",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/transform.js

@@ -1189,8 +1189,25 @@ var defaults = {
   barrelImportPackages: [],
   importAliases: {},
   renames: true,
-  noExternal: false
+  noExternal: false,
+  keyPatterns: [{
+    target: "service",
+    pattern: "default",
+    skipLeadingPath: ["src/"]
+  }]
 };
+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",
+      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/"]
+    });
+  }
+  return result;
+}
 function parse(config) {
   return {
     refactors: isObject(config) && hasProperty(config, "refactors") && isBoolean(config.refactors) ? config.refactors : defaults.refactors,
@@ -1208,7 +1225,8 @@ function parse(config) {
     importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map2(config.importAliases, (value) => String(value)) : defaults.importAliases,
     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
+    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
   };
 }
 
@@ -3462,6 +3480,128 @@ var classSelfMismatch = createDiagnostic({
   })
 });
 
+// src/core/KeyBuilder.ts
+var makeKeyBuilder = fn("KeyBuilder")(
+  function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    const packageInfo = tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
+    function createString2(classNameText, kind) {
+      if (!packageInfo) return;
+      for (const keyPattern of options.keyPatterns) {
+        if (keyPattern.target !== kind) continue;
+        const lastIndex = sourceFile.fileName.lastIndexOf("/");
+        let onlyFileName = lastIndex === -1 ? "" : sourceFile.fileName.slice(lastIndex + 1);
+        const lastExtensionIndex = onlyFileName.lastIndexOf(".");
+        if (lastExtensionIndex !== -1) onlyFileName = onlyFileName.slice(0, lastExtensionIndex);
+        if (onlyFileName.toLowerCase().endsWith("/index")) onlyFileName = onlyFileName.slice(0, -6);
+        if (onlyFileName.startsWith("/")) onlyFileName = onlyFileName.slice(1);
+        let subDirectory = getDirectoryPath(ts, sourceFile.fileName);
+        if (!subDirectory.startsWith(packageInfo.packageDirectory)) continue;
+        subDirectory = subDirectory.slice(packageInfo.packageDirectory.length);
+        if (!subDirectory.endsWith("/")) subDirectory = subDirectory + "/";
+        if (subDirectory.startsWith("/")) subDirectory = subDirectory.slice(1);
+        for (const prefix of keyPattern.skipLeadingPath) {
+          if (subDirectory.startsWith(prefix)) {
+            subDirectory = subDirectory.slice(prefix.length);
+            break;
+          }
+        }
+        let parts = [packageInfo.name, subDirectory, onlyFileName].concat(
+          onlyFileName.toLowerCase() === classNameText.toLowerCase() ? [] : [classNameText]
+        );
+        if (keyPattern.pattern === "package-identifier") {
+          parts = [packageInfo.name, onlyFileName].concat(
+            onlyFileName.toLowerCase() === classNameText.toLowerCase() ? [] : [classNameText]
+          );
+        }
+        parts = parts.map((part) => part.startsWith("/") ? part.slice(1) : part).map(
+          (part) => part.endsWith("/") ? part.slice(0, -1) : part
+        );
+        return parts.filter((_) => String(_).trim().length > 0).join("/");
+      }
+    }
+    return {
+      createString: createString2
+    };
+  }
+);
+var keyBuilderCache = /* @__PURE__ */ new Map();
+var getOrMakeKeyBuilder = fn("getOrMakeKeyBuilder")(function* (sourceFile) {
+  const keyBuilder = keyBuilderCache.get(sourceFile.fileName) || (yield* makeKeyBuilder(sourceFile));
+  keyBuilderCache.set(sourceFile.fileName, keyBuilder);
+  return keyBuilder;
+});
+function createString(sourceFile, identifier, kind) {
+  return map4(
+    getOrMakeKeyBuilder(sourceFile),
+    (identifierBuilder) => identifierBuilder.createString(identifier, kind)
+  );
+}
+
+// src/diagnostics/deterministicKeys.ts
+var deterministicKeys = createDiagnostic({
+  name: "deterministicKeys",
+  code: 25,
+  severity: "off",
+  apply: fn("deterministicKeys.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          pipe(
+            typeParser.extendsEffectService(node),
+            orElse2(() => typeParser.extendsContextTag(node)),
+            orElse2(() => typeParser.extendsEffectTag(node)),
+            map4(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "service" }))
+          ),
+          orElse2(
+            () => pipe(
+              typeParser.extendsDataTaggedError(node),
+              orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+              map4(({ className, keyStringLiteral }) => ({ keyStringLiteral, className, target: "error" }))
+            )
+          ),
+          orElse2(() => void_)
+        );
+        if (result && result.keyStringLiteral) {
+          const { className, keyStringLiteral } = result;
+          const classNameText = ts.idText(className);
+          const expectedKey = yield* createString(sourceFile, classNameText, result.target);
+          if (!expectedKey) return;
+          const actualIdentifier = keyStringLiteral.text;
+          if (actualIdentifier !== expectedKey) {
+            report({
+              location: keyStringLiteral,
+              messageText: `Key should be '${expectedKey}'`,
+              fixes: [{
+                fixName: "deterministicKeys_fix",
+                description: `Replace '${actualIdentifier}' with '${expectedKey}'`,
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const newStringLiteral = ts.factory.createStringLiteral(expectedKey);
+                  changeTracker.replaceNode(sourceFile, keyStringLiteral, newStringLiteral);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -5471,7 +5611,8 @@ var diagnostics = [
   outdatedEffectCodegen,
   overriddenSchemaConstructor,
   unsupportedServiceAccessors,
-  nonObjectEffectServiceType
+  nonObjectEffectServiceType,
+  deterministicKeys
 ];
 
 // src/transform.ts