@slip-stream-kit/eslint-plugin 0.44.0 → 0.45.0

package/dist/index.js

@@ -4348,6 +4348,235 @@ var requireJsdocExample = {
   }
 };
 
+// src/rules/services-namespace-import/services-namespace-import.ts
+var DEFAULT_NAME = "service";
+var BARREL_FILE = /\/index\.[cm]?[jt]sx?$/;
+var SERVICES_SPECIFIER = /^\.{1,2}\/(?:.*\/)?services(?:\/index)?(?:\.[cm]?[jt]sx?)?$/;
+var isTypeOnly = (node) => {
+  return node.importKind === "type";
+};
+var isValueBinding = (specifier) => {
+  return specifier.type !== "ImportNamespaceSpecifier" && !isTypeOnly(specifier);
+};
+var importedName = (specifier) => {
+  if (specifier.type === "ImportDefaultSpecifier") {
+    return "default";
+  }
+  if (specifier.type === "ImportSpecifier") {
+    return specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+  }
+  return specifier.local.name;
+};
+var isShadowedAt = (reference, name) => {
+  let scope = reference.from;
+  while (scope !== null && scope.type !== "module" && scope.type !== "global") {
+    if (scope.set.has(name)) {
+      return true;
+    }
+    scope = scope.upper;
+  }
+  return false;
+};
+var isRewritable = (reference, name) => {
+  const identifier = reference.identifier;
+  return identifier.type !== "JSXIdentifier" && identifier.parent?.type !== "ExportSpecifier" && !isShadowedAt(reference, name);
+};
+var referenceEdit = (reference, local, member) => {
+  const identifier = reference.identifier;
+  const parent = identifier.parent;
+  if (parent?.type === "Property" && parent.shorthand && parent.value === identifier) {
+    return { range: parent.range, text: `${local}: ${member}` };
+  }
+  return { range: identifier.range, text: member };
+};
+var rewriteBindings = (bindings, name) => {
+  const references = bindings.flatMap(({ variable, member }) => {
+    return variable.references.map((reference) => {
+      return { reference, local: variable.name, member };
+    });
+  });
+  const allRewritable = references.every(({ reference }) => {
+    return isRewritable(reference, name);
+  });
+  if (!allRewritable) {
+    return null;
+  }
+  return references.map(({ reference, local, member }) => {
+    return referenceEdit(reference, local, member === "" ? name : `${name}.${member}`);
+  });
+};
+var typeImportLine = (declaration, sourceCode) => {
+  const names = declaration.specifiers.filter(isTypeOnly).map((specifier) => {
+    return sourceCode.getText(specifier).replace(/^type\s+/, "");
+  });
+  return names.length === 0 ? null : `import type { ${names.join(", ")} } from ${sourceCode.getText(declaration.source)}`;
+};
+var lineRange = (declaration, sourceCode) => {
+  const [start, end] = declaration.range;
+  return [start, sourceCode.text[end] === "\n" ? end + 1 : end];
+};
+var isNameTaken = (sourceCode, program, name, except) => {
+  const moduleScope = sourceCode.getScope(program).childScopes.find((scope) => {
+    return scope.type === "module";
+  });
+  const variable = moduleScope?.set.get(name);
+  return variable !== void 0 && variable.defs.some((def) => {
+    return def.node !== except;
+  });
+};
+var namespacesOf = (group) => {
+  return group.flatMap((declaration) => {
+    return declaration.specifiers.filter((specifier) => {
+      return specifier.type === "ImportNamespaceSpecifier";
+    });
+  });
+};
+var reportWrongNamespaces = (ctx, wrong) => {
+  const { context, sourceCode, source, name } = ctx;
+  for (const specifier of wrong) {
+    const variable = sourceCode.getDeclaredVariables(specifier)[0];
+    const edits = ctx.canFix && wrong.length === 1 && variable ? rewriteBindings([{ variable, member: "" }], name) : null;
+    context.report({
+      node: specifier,
+      messageId: "namespaceName",
+      data: { source, name, actual: specifier.local.name },
+      fix: edits === null ? null : (fixer) => {
+        return [
+          fixer.replaceText(specifier.local, name),
+          ...edits.map((edit) => {
+            return fixer.replaceTextRange(edit.range, edit.text);
+          })
+        ];
+      }
+    });
+  }
+};
+var reportNamedImports = (ctx, offending, hasNamespace) => {
+  const { context, sourceCode, source, name } = ctx;
+  const bindings = offending.flatMap((declaration) => {
+    return declaration.specifiers.filter(isValueBinding).map((specifier) => {
+      return { variable: sourceCode.getDeclaredVariables(specifier)[0], member: importedName(specifier) };
+    });
+  });
+  const edits = ctx.canFix ? rewriteBindings(bindings, name) : null;
+  const host = hasNamespace ? void 0 : offending[0];
+  const declarationFix = (fixer, declaration) => {
+    const lines = [
+      declaration === host ? `import * as ${name} from ${sourceCode.getText(declaration.source)}` : null,
+      typeImportLine(declaration, sourceCode)
+    ].filter((line) => {
+      return line !== null;
+    });
+    return lines.length === 0 ? fixer.removeRange(lineRange(declaration, sourceCode)) : fixer.replaceText(declaration, lines.join("\n"));
+  };
+  for (const declaration of offending) {
+    context.report({
+      node: declaration,
+      messageId: "namedImport",
+      data: { source, name },
+      fix: edits === null || declaration !== offending[0] ? null : (fixer) => {
+        return [
+          ...offending.map((each) => {
+            return declarationFix(fixer, each);
+          }),
+          ...edits.map((edit) => {
+            return fixer.replaceTextRange(edit.range, edit.text);
+          })
+        ];
+      }
+    });
+  }
+};
+var checkGroup = (ctx, program) => {
+  const namespaces = namespacesOf(ctx.group);
+  const correct = namespaces.find((specifier) => {
+    return specifier.local.name === ctx.name;
+  });
+  const wrong = namespaces.filter((specifier) => {
+    return specifier !== correct;
+  });
+  const nameTaken = isNameTaken(ctx.sourceCode, program, ctx.name, correct);
+  reportWrongNamespaces({ ...ctx, canFix: ctx.canFix && correct === void 0 && !nameTaken }, wrong);
+  const offending = ctx.group.filter((declaration) => {
+    return declaration.specifiers.some(isValueBinding);
+  });
+  if (offending.length > 0) {
+    reportNamedImports({ ...ctx, canFix: ctx.canFix && wrong.length === 0 && !nameTaken }, offending, !!correct);
+  }
+};
+var servicesNamespaceImport = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Import a feature's `services` module only as a namespace (`import * as service from '../services'`).",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#services-namespace-import"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            minLength: 1,
+            description: `The namespace binding (default '${DEFAULT_NAME}').`
+          },
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. When provided, the rule only runs for files whose path matches one of them."
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. The rule is skipped for files whose path matches one of them, even if it also matches `paths`."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      namedImport: "Import `{{source}}` as a namespace \u2014 `import * as {{name}} from '{{source}}'` \u2014 and read members as `{{name}}.<member>`.",
+      namespaceName: "Name the `{{source}}` namespace `{{name}}`, not `{{actual}}`."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    if (BARREL_FILE.test(filename) || !isInScope(filename, options.paths ?? [], options.ignore ?? []) || !isUiPackageFile(filename)) {
+      return {};
+    }
+    const declarations = [];
+    return {
+      ImportDeclaration(node) {
+        if (!isTypeOnly(node) && typeof node.source.value === "string" && SERVICES_SPECIFIER.test(node.source.value)) {
+          declarations.push(node);
+        }
+      },
+      "Program:exit": function(program) {
+        const bySource = Map.groupBy(declarations, (declaration) => {
+          return String(declaration.source.value);
+        });
+        for (const [source, group] of bySource) {
+          checkGroup(
+            {
+              context,
+              sourceCode: context.sourceCode,
+              source,
+              group,
+              name: options.name ?? DEFAULT_NAME,
+              // Two different services modules cannot share one namespace name.
+              canFix: bySource.size === 1
+            },
+            program
+          );
+        }
+      }
+    };
+  }
+};
+
 // src/rules/test-location/test-location.ts
 var TEST_FILE3 = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 var SPEC_SUFFIX = /\.spec(\.[cm]?[jt]sx?)$/;
@@ -4470,6 +4699,7 @@ var rules = {
   "atom-naming": atomNaming,
   "no-hooks-in-services": noHooksInServices,
   "feature-files": featureFiles,
+  "services-namespace-import": servicesNamespaceImport,
   "component-name-matches-file": componentNameMatchesFile,
   "component-classname": componentClassname,
   "dumb-component-purity": dumbComponentPurity
@@ -4480,7 +4710,7 @@ var PLUGIN_NAME = "@wl";
 var plugin = {
   meta: {
     name: "@wl/eslint-plugin",
-    version: "0.44.0"
+    version: "0.45.0"
   },
   rules,
   configs: {}
@@ -4605,6 +4835,7 @@ plugin.configs.recommended = [
       [`${PLUGIN_NAME}/atom-naming`]: "error",
       [`${PLUGIN_NAME}/no-hooks-in-services`]: "error",
       [`${PLUGIN_NAME}/feature-files`]: "error",
+      [`${PLUGIN_NAME}/services-namespace-import`]: "error",
       [`${PLUGIN_NAME}/component-name-matches-file`]: "error",
       [`${PLUGIN_NAME}/component-classname`]: "error",
       [`${PLUGIN_NAME}/dumb-component-purity`]: "error"