@foldkit/oxlint-plugin 0.11.0-canary.69ecbe18bcfc → 0.11.0-canary.790e96da0b63

package/all.json

@@ -31,6 +31,7 @@
     "foldkit/no-raw-dom-event-attributes": "error",
     "foldkit/no-spread-in-evo": "error",
     "foldkit/prefer-callable-message-constructor": "error",
+    "foldkit/prefer-effect-module-names": "error",
     "foldkit/require-rel-for-external-link": "error",
     "foldkit/selection-submodel-factory-at-module-scope": "error",
     "foldkit/wrap-child-output-in-got-message": "error"

package/dist/index.d.ts

@@ -37,6 +37,7 @@ declare const _default: {
         readonly 'no-raw-dom-event-attributes': import("effect-oxlint").CreateRule;
         readonly 'no-spread-in-evo': import("effect-oxlint").CreateRule;
         readonly 'prefer-callable-message-constructor': import("effect-oxlint").CreateRule;
+        readonly 'prefer-effect-module-names': import("effect-oxlint").CreateRule;
         readonly 'require-rel-for-external-link': import("effect-oxlint").CreateRule;
         readonly 'selection-submodel-factory-at-module-scope': import("effect-oxlint").CreateRule;
         readonly 'wrap-child-output-in-got-message': import("effect-oxlint").CreateRule;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAmEtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyEG,WAAW;QACX,GAAG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAqEtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyEG,WAAW;QACX,GAAG"}

package/dist/index.js

@@ -13360,6 +13360,139 @@ var preferCallableMessageConstructor = Rule_exports.define({
   }
 });
 
+// src/rules/prefer-effect-module-names.ts
+var EFFECT_MODULE_NAME = /^[A-Z]/;
+var isSemanticConflictAlias = (name, localName) => localName === `Effect${name}`;
+var importedName2 = (specifier) => {
+  if (isIdentifier(specifier.imported)) {
+    return Option_exports.some(specifier.imported.name);
+  }
+  if (isStringLiteral(specifier.imported)) {
+    return Option_exports.some(specifier.imported.value);
+  }
+  return Option_exports.none();
+};
+var importVariable = (ctx, specifier) => {
+  const scopeManager = ctx.sourceCode.scopeManager;
+  if (scopeManager === void 0) {
+    return void 0;
+  }
+  return Array_exports.findFirst(
+    scopeManager.getDeclaredVariables(specifier),
+    (variable) => variable.name === specifier.local.name
+  ).pipe(Option_exports.getOrUndefined);
+};
+var hasUnshadowedReference = (ctx, name) => Array_exports.some(
+  ctx.sourceCode.scopeManager?.scopes ?? [],
+  (scope3) => Array_exports.some(
+    scope3.references,
+    (reference) => reference.identifier.name === name && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs))
+  )
+);
+var preservesObservableName = (node) => {
+  const parent = node.parent;
+  if (parent === null) {
+    return true;
+  }
+  if (parent.type === "Property" && parent.shorthand) {
+    return false;
+  }
+  return parent.type !== "ExportSpecifier";
+};
+var hasInterveningBinding = (scope3, importScope, name) => {
+  if (scope3 === importScope) {
+    return false;
+  }
+  if (scope3.set.get(name) !== void 0 || scope3.upper === null) {
+    return true;
+  }
+  return hasInterveningBinding(scope3.upper, importScope, name);
+};
+var referenceCanBeRenamed = (reference, importScope, name) => preservesObservableName(reference.identifier) && !hasInterveningBinding(reference.from, importScope, name);
+var aliasedEffectModule = (specifier) => {
+  if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") {
+    return Option_exports.none();
+  }
+  return Option_exports.flatMap(
+    importedName2(specifier),
+    (name) => EFFECT_MODULE_NAME.test(name) && specifier.local.name !== name && !isSemanticConflictAlias(name, specifier.local.name) ? Option_exports.some({ specifier, name }) : Option_exports.none()
+  );
+};
+var importsEffectModuleAsAlias = (variable, name) => Array_exports.some(variable.defs, (definition) => {
+  if (definition.type !== "ImportBinding" || definition.node.type !== "ImportSpecifier") {
+    return false;
+  }
+  const declaration = definition.node.parent;
+  if (declaration.type !== "ImportDeclaration" || declaration.source.value !== "effect" || declaration.importKind === "type") {
+    return false;
+  }
+  return Option_exports.match(aliasedEffectModule(definition.node), {
+    onNone: () => false,
+    onSome: (alias) => alias.name === name
+  });
+});
+var hasCompetingRenameTarget = (variable, name) => Array_exports.some(
+  variable.scope.variables,
+  (candidate) => candidate !== variable && importsEffectModuleAsAlias(candidate, name)
+);
+var canRenameBinding = (ctx, variable, name) => variable.scope.set.get(name) === void 0 && !hasUnshadowedReference(ctx, name) && !hasCompetingRenameTarget(variable, name) && Array_exports.every(
+  variable.references,
+  (reference) => referenceCanBeRenamed(reference, variable.scope, name)
+);
+var fixesForAlias = (ctx, { specifier, name }) => {
+  const variable = importVariable(ctx, specifier);
+  if (variable === void 0 || Array_exports.isArrayNonEmpty(ctx.sourceCode.getCommentsInside(specifier)) || !canRenameBinding(ctx, variable, name)) {
+    return [];
+  }
+  return [
+    Diagnostic_exports.replaceText(specifier, name),
+    ...Array_exports.map(
+      variable.references,
+      (reference) => Diagnostic_exports.replaceText(reference.identifier, name)
+    )
+  ];
+};
+var preferEffectModuleNames = Rule_exports.define({
+  name: "prefer-effect-module-names",
+  meta: Rule_exports.meta({
+    type: "suggestion",
+    description: "Use Effect module names without import aliases.",
+    fixable: "code"
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext;
+    return {
+      ImportDeclaration: (node) => {
+        if (node.type !== "ImportDeclaration" || node.source.value !== "effect" || node.importKind === "type") {
+          return Effect_exports.void;
+        }
+        const aliases = Array_exports.flatMap(
+          node.specifiers,
+          (specifier) => Option_exports.match(aliasedEffectModule(specifier), {
+            onNone: () => [],
+            onSome: (alias) => [alias]
+          })
+        );
+        if (Array_exports.isReadonlyArrayEmpty(aliases)) {
+          return Effect_exports.void;
+        }
+        const replacements = Array_exports.map(
+          aliases,
+          ({ specifier, name }) => `\`${name}\` instead of \`${specifier.local.name}\``
+        );
+        const diagnostic = Diagnostic_exports.make({
+          node,
+          message: `Use Effect module names without aliases: ${replacements.join(", ")}. Qualify same-named globals through \`globalThis\`.`
+        });
+        const fixes = Array_exports.flatMap(aliases, (alias) => fixesForAlias(ctx, alias));
+        return ctx.report(
+          Array_exports.isReadonlyArrayEmpty(fixes) ? diagnostic : Diagnostic_exports.withFix(diagnostic, Diagnostic_exports.composeFixes(...fixes))
+        );
+      }
+    };
+  }
+});
+
 // src/rules/require-rel-for-external-link.ts
 var protectiveRelSubstrings = ["noopener", "noreferrer"];
 var isTargetBlankElement = (element) => {
@@ -13752,6 +13885,7 @@ var basePlugin = Plugin_exports.define({
     "no-raw-dom-event-attributes": noRawDomEventAttributes,
     "no-spread-in-evo": noSpreadInEvo,
     "prefer-callable-message-constructor": preferCallableMessageConstructor,
+    "prefer-effect-module-names": preferEffectModuleNames,
     "require-rel-for-external-link": requireRelForExternalLink,
     "selection-submodel-factory-at-module-scope": selectionSubmodelFactoryAtModuleScope,
     "wrap-child-output-in-got-message": wrapChildOutputInGotMessage
@@ -13795,13 +13929,11 @@ var entryOverride = {
     [decisionTimeRuleId]: "off"
   }
 };
+var rulesApplicableToTests = /* @__PURE__ */ new Set(["foldkit/prefer-effect-module-names"]);
 var testOverride = (config) => ({
   files: testFilePatterns,
   rules: Object.fromEntries(
-    Object.keys(config.rules).map((id) => [
-      id,
-      "off"
-    ])
+    Object.keys(config.rules).filter((id) => !rulesApplicableToTests.has(id)).map((id) => [id, "off"])
   )
 });
 var withOverrides = (config) => ({

package/dist/rules/prefer-effect-module-names.d.ts

@@ -0,0 +1,3 @@
+/** Requires PascalCase Effect modules to keep their exported names. */
+export declare const preferEffectModuleNames: import("effect-oxlint").CreateRule;
+//# sourceMappingURL=prefer-effect-module-names.d.ts.map

package/dist/rules/prefer-effect-module-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-effect-module-names.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-effect-module-names.ts"],"names":[],"mappings":"AAyLA,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,oCAkDlC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/oxlint-plugin",
-  "version": "0.11.0-canary.69ecbe18bcfc",
+  "version": "0.11.0-canary.790e96da0b63",
   "description": "Oxlint rules for Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",

package/recommended.json

@@ -31,6 +31,7 @@
     "foldkit/no-raw-dom-event-attributes": "error",
     "foldkit/no-spread-in-evo": "error",
     "foldkit/prefer-callable-message-constructor": "error",
+    "foldkit/prefer-effect-module-names": "error",
     "foldkit/require-rel-for-external-link": "error",
     "foldkit/selection-submodel-factory-at-module-scope": "error",
     "foldkit/wrap-child-output-in-got-message": "error"