@noctcore/eslint-plugin-architecture 0.2.0 → 0.3.0

package/README.md

@@ -55,3 +55,4 @@ ESLint against real file paths, not virtual sources.
 | [`index-must-reexport-default`](./docs/rules/index-must-reexport-default.md) | A component folder's `index.ts` must re-export the sibling default named after the folder. | |
 | [`max-import-depth`](./docs/rules/max-import-depth.md) | A relative import may not climb more than `max` parent levels (default 3); autofixed to a path alias when one is configured. | 🔧 |
 | [`no-cross-feature-imports`](./docs/rules/no-cross-feature-imports.md) | A file in one feature may not import runtime code from another feature. | |
+| [`single-semantic-module`](./docs/rules/single-semantic-module.md) | A module exports one semantic concern (types, constants, functions, classes, components, hooks, schemas or enums); private helpers do not count. Off until configured. | |

package/dist/index.cjs

@@ -48,7 +48,12 @@ var recommended = {
   "noctcore-architecture/filename-matches-export": "error",
   "noctcore-architecture/index-must-reexport-default": "error",
   "noctcore-architecture/max-import-depth": "error",
-  "noctcore-architecture/no-cross-feature-imports": "error"
+  "noctcore-architecture/no-cross-feature-imports": "error",
+  // Ships OFF: which files it governs and which category mixes they may keep
+  // (a NestJS `.constants.ts` legitimately holds constants, types and enums) is
+  // a per-codebase decision best made from measured counts. Enable it with
+  //   'noctcore-architecture/single-semantic-module': ['error', { allow: [['constant', 'type', 'enum']] }]
+  "noctcore-architecture/single-semantic-module": "off"
 };
 
 // src/rules/barrel-purity.ts
@@ -794,6 +799,578 @@ var noCrossFeatureImportsRule = createRule({
   }
 });
 
+// src/semantic-module/classify.ts
+var import_utils15 = require("@typescript-eslint/utils");
+
+// src/semantic-module/ast.ts
+var import_utils13 = require("@typescript-eslint/utils");
+function getDeclarationName(node) {
+  if ("id" in node) {
+    const id = node.id;
+    if (isIdentifier(id)) {
+      return id.name;
+    }
+  }
+  return void 0;
+}
+function getVariableDeclaratorName(declarator) {
+  return declarator.id.type === import_utils13.AST_NODE_TYPES.Identifier ? declarator.id.name : void 0;
+}
+function isWrapperExpression(expression) {
+  return expression.type === import_utils13.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils13.AST_NODE_TYPES.TSTypeAssertion || expression.type === import_utils13.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils13.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils13.AST_NODE_TYPES.TSInstantiationExpression;
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (isWrapperExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function isAmbientDeclaration(node) {
+  if ("declare" in node && node.declare === true) {
+    return true;
+  }
+  return node.type === import_utils13.AST_NODE_TYPES.TSModuleDeclaration && node.kind === "global";
+}
+function functionReturnsJsx(node) {
+  if (node.type === import_utils13.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (!node.expression && node.body.type === import_utils13.AST_NODE_TYPES.BlockStatement) {
+      return blockReturnsJsx(node.body);
+    }
+    return containsJsx(node.body);
+  }
+  return blockReturnsJsx(node.body);
+}
+function blockReturnsJsx(block) {
+  return containsNode(block, (node) => {
+    if (node.type !== import_utils13.AST_NODE_TYPES.ReturnStatement || !node.argument) {
+      return false;
+    }
+    return containsJsx(node.argument);
+  });
+}
+function containsJsx(node) {
+  return containsNode(
+    node,
+    (candidate) => candidate.type === import_utils13.AST_NODE_TYPES.JSXElement || candidate.type === import_utils13.AST_NODE_TYPES.JSXFragment
+  );
+}
+var SKIPPED_KEYS = /* @__PURE__ */ new Set(["parent", "loc", "range", "tokens", "comments"]);
+function containsNode(root, predicate) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    if (predicate(current)) {
+      return true;
+    }
+    for (const [key, value] of Object.entries(current)) {
+      if (SKIPPED_KEYS.has(key)) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (isNodeLike(item)) {
+            stack.push(item);
+          }
+        }
+        continue;
+      }
+      if (isNodeLike(value)) {
+        stack.push(value);
+      }
+    }
+  }
+  return false;
+}
+function isNodeLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function isIdentifier(value) {
+  return isNodeLike(value) && value.type === import_utils13.AST_NODE_TYPES.Identifier;
+}
+
+// src/semantic-module/classifiers.ts
+var import_utils14 = require("@typescript-eslint/utils");
+function isHookName(name, options) {
+  if (!options.hookDetection.enabled || !name) {
+    return false;
+  }
+  return options.hookDetection.namePattern.test(name);
+}
+function isReactComponentName(name) {
+  return Boolean(name && /^[A-Z][A-Za-z0-9]*$/u.test(name));
+}
+function isReactComponentFunction(node, name, options, isDefaultExport = false) {
+  if (!options.reactComponentDetection.enabled) {
+    return false;
+  }
+  if (!isReactComponentName(name) && !isDefaultExport) {
+    return false;
+  }
+  if (node.returnType && typeReferencesJsxValue(node.returnType.typeAnnotation)) {
+    return true;
+  }
+  return functionReturnsJsx(node);
+}
+function isReactComponentVariable(declarator, options) {
+  if (!options.reactComponentDetection.enabled) {
+    return false;
+  }
+  const name = getVariableDeclaratorName(declarator);
+  if (!isReactComponentName(name)) {
+    return false;
+  }
+  if (declarator.id.type === import_utils14.AST_NODE_TYPES.Identifier && declarator.id.typeAnnotation && typeReferencesReactComponent(declarator.id.typeAnnotation.typeAnnotation)) {
+    return true;
+  }
+  if (!declarator.init) {
+    return false;
+  }
+  if (declarator.init.type === import_utils14.AST_NODE_TYPES.ArrowFunctionExpression || declarator.init.type === import_utils14.AST_NODE_TYPES.FunctionExpression) {
+    return isReactComponentFunction(declarator.init, name, options);
+  }
+  return containsJsx(declarator.init);
+}
+var REACT_COMPONENT_TYPES = /* @__PURE__ */ new Set([
+  "FC",
+  "FunctionComponent",
+  "React.FC",
+  "React.FunctionComponent"
+]);
+var JSX_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "JSX.Element",
+  "React.ReactElement",
+  "React.ReactNode"
+]);
+function typeReferencesReactComponent(node) {
+  return containsNode(
+    node,
+    (candidate) => candidate.type === import_utils14.AST_NODE_TYPES.TSTypeReference && REACT_COMPONENT_TYPES.has(entityNameToString(candidate.typeName))
+  );
+}
+function typeReferencesJsxValue(node) {
+  return containsNode(
+    node,
+    (candidate) => candidate.type === import_utils14.AST_NODE_TYPES.TSTypeReference && JSX_VALUE_TYPES.has(entityNameToString(candidate.typeName))
+  );
+}
+function entityNameToString(entityName) {
+  if (entityName.type === import_utils14.AST_NODE_TYPES.Identifier) {
+    return entityName.name;
+  }
+  if (entityName.type === import_utils14.AST_NODE_TYPES.TSQualifiedName) {
+    return `${entityNameToString(entityName.left)}.${entityName.right.name}`;
+  }
+  return "this";
+}
+var SCHEMA_LIBRARY_MODULES = {
+  zod: ["zod"],
+  yup: ["yup"],
+  valibot: ["valibot"]
+};
+var SCHEMA_BUILDER_NAMES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "date",
+  "enum",
+  "literal",
+  "number",
+  "object",
+  "record",
+  "string",
+  "tuple",
+  "union"
+]);
+function collectSchemaImportContext(program, options) {
+  const namespaceIdentifiers = /* @__PURE__ */ new Set();
+  const builderIdentifiers = /* @__PURE__ */ new Set();
+  const enabledModules = new Set(
+    options.schemaLibraries.flatMap((library) => SCHEMA_LIBRARY_MODULES[library])
+  );
+  for (const statement of program.body) {
+    if (statement.type !== import_utils14.AST_NODE_TYPES.ImportDeclaration || statement.importKind === "type" || !enabledModules.has(String(statement.source.value))) {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils14.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        namespaceIdentifiers.add(specifier.local.name);
+        continue;
+      }
+      if (specifier.importKind === "type") {
+        continue;
+      }
+      const importedName = specifier.imported.type === import_utils14.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+      if (importedName === "z") {
+        namespaceIdentifiers.add(specifier.local.name);
+      }
+      if (SCHEMA_BUILDER_NAMES.has(importedName)) {
+        builderIdentifiers.add(specifier.local.name);
+      }
+    }
+  }
+  return { namespaceIdentifiers, builderIdentifiers };
+}
+function isSchemaExpression(expression, context) {
+  const unwrapped = unwrapExpression(expression);
+  if (unwrapped.type !== import_utils14.AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+  const rootName = expressionRootIdentifier(unwrapped.callee);
+  if (!rootName) {
+    return false;
+  }
+  return context.namespaceIdentifiers.has(rootName) || context.builderIdentifiers.has(rootName);
+}
+function expressionRootIdentifier(node) {
+  switch (node.type) {
+    case import_utils14.AST_NODE_TYPES.Identifier:
+      return node.name;
+    case import_utils14.AST_NODE_TYPES.MemberExpression:
+      return expressionRootIdentifier(node.object);
+    case import_utils14.AST_NODE_TYPES.CallExpression:
+      return expressionRootIdentifier(node.callee);
+    case import_utils14.AST_NODE_TYPES.ChainExpression:
+      return expressionRootIdentifier(node.expression);
+    default:
+      return null;
+  }
+}
+function getConstantReason(expression) {
+  if (!expression) {
+    return "top-level variable declaration without initializer";
+  }
+  switch (unwrapExpression(expression).type) {
+    case import_utils14.AST_NODE_TYPES.Literal:
+      return "literal runtime value";
+    case import_utils14.AST_NODE_TYPES.ObjectExpression:
+      return "object literal runtime value";
+    case import_utils14.AST_NODE_TYPES.ArrayExpression:
+      return "array literal runtime value";
+    case import_utils14.AST_NODE_TYPES.TemplateLiteral:
+      return "template literal runtime value";
+    case import_utils14.AST_NODE_TYPES.CallExpression:
+      return "computed top-level runtime value";
+    default:
+      return "top-level runtime value";
+  }
+}
+
+// src/semantic-module/options.ts
+var SEMANTIC_CATEGORIES = [
+  "type",
+  "constant",
+  "function",
+  "class",
+  "react-component",
+  "hook",
+  "schema",
+  "enum"
+];
+var SCHEMA_LIBRARIES = ["zod", "yup", "valibot"];
+function sortCategories(categories) {
+  const categorySet = new Set(categories);
+  return SEMANTIC_CATEGORIES.filter((category) => categorySet.has(category));
+}
+var DEFAULT_HOOK_NAME_PATTERN = "^use[A-Z0-9].*";
+var DEFAULT_OPTIONS = {
+  allow: [],
+  enumCategory: "enum",
+  debug: false,
+  ignoreAmbientDeclarations: false,
+  ignorePrivateDeclarations: true,
+  schemaLibraries: SCHEMA_LIBRARIES,
+  reactComponentDetection: { enabled: true },
+  hookDetection: { enabled: true, namePattern: DEFAULT_HOOK_NAME_PATTERN }
+};
+function normalizeOptions(options) {
+  return {
+    allow: options.allow ?? DEFAULT_OPTIONS.allow,
+    enumCategory: options.enumCategory ?? DEFAULT_OPTIONS.enumCategory,
+    debug: options.debug ?? DEFAULT_OPTIONS.debug,
+    ignoreAmbientDeclarations: options.ignoreAmbientDeclarations ?? DEFAULT_OPTIONS.ignoreAmbientDeclarations,
+    ignorePrivateDeclarations: options.ignorePrivateDeclarations ?? DEFAULT_OPTIONS.ignorePrivateDeclarations,
+    schemaLibraries: options.schemaLibraries ?? DEFAULT_OPTIONS.schemaLibraries,
+    reactComponentDetection: { enabled: options.reactComponentDetection?.enabled ?? true },
+    hookDetection: {
+      enabled: options.hookDetection?.enabled ?? true,
+      namePattern: compilePattern(options.hookDetection?.namePattern ?? DEFAULT_HOOK_NAME_PATTERN)
+    }
+  };
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    throw new Error(
+      `single-semantic-module: hookDetection.namePattern ${JSON.stringify(pattern)} is not a valid regular expression (${String(error)}).`
+    );
+  }
+}
+function isCategorySetAllowed(categories, allow) {
+  if (categories.size <= 1) {
+    return true;
+  }
+  const detected = [...categories];
+  return allow.some((group) => {
+    const allowed = new Set(group);
+    return detected.every((category) => allowed.has(category));
+  });
+}
+
+// src/semantic-module/classify.ts
+function analyzeSemanticModule(program, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const context = {
+    options,
+    schemaImports: collectSchemaImportContext(program, options),
+    exportedNames: collectLocallyExportedNames(program)
+  };
+  const classifications = program.body.flatMap(
+    (statement) => classifyTopLevelStatement(statement, context)
+  );
+  return {
+    categories: new Set(classifications.map((classification2) => classification2.category)),
+    classifications,
+    options
+  };
+}
+function collectLocallyExportedNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type === import_utils15.AST_NODE_TYPES.ExportNamedDeclaration && statement.source === null && statement.declaration === null) {
+      for (const specifier of statement.specifiers) {
+        if (specifier.local.type === import_utils15.AST_NODE_TYPES.Identifier) {
+          names.add(specifier.local.name);
+        }
+      }
+    } else if (statement.type === import_utils15.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils15.AST_NODE_TYPES.Identifier) {
+      names.add(statement.declaration.name);
+    }
+  }
+  return names;
+}
+function classifyTopLevelStatement(statement, context) {
+  switch (statement.type) {
+    case import_utils15.AST_NODE_TYPES.ImportDeclaration:
+    case import_utils15.AST_NODE_TYPES.EmptyStatement:
+    case import_utils15.AST_NODE_TYPES.ExportAllDeclaration:
+      return [];
+    case import_utils15.AST_NODE_TYPES.ExportNamedDeclaration:
+      return statement.declaration ? classifyDeclarationLike(statement.declaration, context) : [];
+    case import_utils15.AST_NODE_TYPES.ExportDefaultDeclaration:
+      return classifyDeclarationLike(statement.declaration, { ...context, isDefaultExport: true });
+    default:
+      if (!context.options.ignorePrivateDeclarations) {
+        return classifyDeclarationLike(statement, context);
+      }
+      return classifyExportedByName(statement, context);
+  }
+}
+function classifyExportedByName(statement, context) {
+  if (context.exportedNames.size === 0) {
+    return [];
+  }
+  if (statement.type === import_utils15.AST_NODE_TYPES.VariableDeclaration) {
+    const exported = statement.declarations.filter((declarator) => {
+      const name2 = getVariableDeclaratorName(declarator);
+      return name2 !== void 0 && context.exportedNames.has(name2);
+    });
+    return exported.map((declarator) => classifyVariableDeclarator(declarator, context));
+  }
+  const name = getDeclarationName(statement);
+  return name !== void 0 && context.exportedNames.has(name) ? classifyDeclarationLike(statement, context) : [];
+}
+function classifyDeclarationLike(node, context) {
+  if (isAmbientDeclaration(node)) {
+    return context.options.ignoreAmbientDeclarations ? [] : [classification("type", node, getDeclarationName(node), "ambient declaration")];
+  }
+  switch (node.type) {
+    case import_utils15.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils15.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils15.AST_NODE_TYPES.TSModuleDeclaration:
+      return [
+        classification("type", node, getDeclarationName(node), "TypeScript type-space declaration")
+      ];
+    case import_utils15.AST_NODE_TYPES.TSEnumDeclaration:
+      return [
+        classification(
+          context.options.enumCategory,
+          node,
+          getDeclarationName(node),
+          context.options.enumCategory === "type" ? "enum configured as type" : "enum declaration"
+        )
+      ];
+    case import_utils15.AST_NODE_TYPES.ClassDeclaration:
+      return [classification("class", node, getDeclarationName(node), "class declaration")];
+    case import_utils15.AST_NODE_TYPES.FunctionDeclaration:
+      return [classifyFunction(node, getDeclarationName(node), context, "function declaration")];
+    case import_utils15.AST_NODE_TYPES.VariableDeclaration:
+      return node.declarations.map((declarator) => classifyVariableDeclarator(declarator, context));
+    case import_utils15.AST_NODE_TYPES.ArrowFunctionExpression:
+    case import_utils15.AST_NODE_TYPES.FunctionExpression:
+      return [classifyFunction(node, void 0, context, "function expression")];
+    case import_utils15.AST_NODE_TYPES.ClassExpression:
+      return [classification("class", node, getDeclarationName(node), "class expression")];
+    case import_utils15.AST_NODE_TYPES.CallExpression:
+    case import_utils15.AST_NODE_TYPES.ArrayExpression:
+    case import_utils15.AST_NODE_TYPES.ObjectExpression:
+    case import_utils15.AST_NODE_TYPES.Literal:
+    case import_utils15.AST_NODE_TYPES.TemplateLiteral:
+      return [classifyDefaultExpression(node, context)];
+    case import_utils15.AST_NODE_TYPES.TSDeclareFunction:
+      return [
+        classification("function", node, getDeclarationName(node), "function overload signature")
+      ];
+    default:
+      return [];
+  }
+}
+function classifyFunction(node, name, context, reason) {
+  if (isHookName(name, context.options)) {
+    return classification("hook", node, name, "function name matches hook pattern");
+  }
+  if (isReactComponentFunction(node, name, context.options, context.isDefaultExport === true)) {
+    return classification(
+      "react-component",
+      node,
+      name,
+      `${reason === "function declaration" ? "function component" : "function expression"} returns JSX or React element`
+    );
+  }
+  return classification("function", node, name, reason);
+}
+function classifyVariableDeclarator(declarator, context) {
+  const name = getVariableDeclaratorName(declarator);
+  const init = declarator.init ? unwrapExpression(declarator.init) : null;
+  if (init && isSchemaExpression(init, context.schemaImports)) {
+    return classification("schema", declarator, name, "schema builder expression");
+  }
+  if (isReactComponentVariable(declarator, context.options)) {
+    return classification("react-component", declarator, name, "React component variable");
+  }
+  if (isHookName(name, context.options)) {
+    return classification("hook", declarator, name, "variable name matches hook pattern");
+  }
+  if (init?.type === import_utils15.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils15.AST_NODE_TYPES.FunctionExpression) {
+    return classifyFunction(init, name, context, "function expression");
+  }
+  if (init?.type === import_utils15.AST_NODE_TYPES.ClassExpression) {
+    return classification("class", declarator, name, "class expression");
+  }
+  return classification("constant", declarator, name, getConstantReason(init));
+}
+function classifyDefaultExpression(expression, context) {
+  const unwrapped = unwrapExpression(expression);
+  if (isSchemaExpression(unwrapped, context.schemaImports)) {
+    return classification("schema", expression, void 0, "default schema expression");
+  }
+  if (unwrapped.type === import_utils15.AST_NODE_TYPES.ArrowFunctionExpression || unwrapped.type === import_utils15.AST_NODE_TYPES.FunctionExpression) {
+    return classifyFunction(unwrapped, void 0, context, "function expression");
+  }
+  if (unwrapped.type === import_utils15.AST_NODE_TYPES.ClassExpression) {
+    return classification("class", expression, void 0, "default class expression");
+  }
+  return classification("constant", expression, void 0, getConstantReason(unwrapped));
+}
+function classification(category, node, declarationName, reason) {
+  return declarationName ? { category, node, reason, declarationName } : { category, node, reason };
+}
+function buildMixedCategoriesMessage(classifications, debug) {
+  const categories = sortCategories(classifications.map((entry) => entry.category));
+  const lines = [
+    "Mixed semantic categories detected in module:",
+    ...categories.map((category) => `- ${category}`)
+  ];
+  if (debug) {
+    lines.push("", "Detected declarations:");
+    for (const entry of classifications) {
+      lines.push(`- ${entry.category}: ${entry.declarationName ?? "<anonymous>"} (${entry.reason})`);
+    }
+  }
+  lines.push(
+    "",
+    "A module must contain only one semantic concern.",
+    "Move declarations into separate files/modules."
+  );
+  return lines.join("\n");
+}
+
+// src/rules/single-semantic-module.ts
+var RULE_NAME8 = "single-semantic-module";
+var optionSchema8 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allow: {
+      type: "array",
+      items: {
+        type: "array",
+        minItems: 2,
+        uniqueItems: true,
+        items: { type: "string", enum: [...SEMANTIC_CATEGORIES] }
+      }
+    },
+    enumCategory: { type: "string", enum: ["enum", "type"] },
+    debug: { type: "boolean" },
+    ignoreAmbientDeclarations: { type: "boolean" },
+    ignorePrivateDeclarations: { type: "boolean" },
+    schemaLibraries: {
+      type: "array",
+      uniqueItems: true,
+      items: { type: "string", enum: [...SCHEMA_LIBRARIES] }
+    },
+    reactComponentDetection: {
+      type: "object",
+      additionalProperties: false,
+      properties: { enabled: { type: "boolean" } }
+    },
+    hookDetection: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        namePattern: { type: "string" }
+      }
+    }
+  }
+};
+var singleSemanticModuleRule = createRule({
+  name: RULE_NAME8,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require each module to export only one semantic concern (types, constants, functions, classes, components, hooks, schemas or enums)."
+    },
+    schema: [optionSchema8],
+    messages: {
+      mixedSemanticCategories: "{{message}}"
+    }
+  },
+  defaultOptions: [DEFAULT_OPTIONS],
+  create(context, [options]) {
+    return {
+      Program(program) {
+        const analysis = analyzeSemanticModule(program, options);
+        if (isCategorySetAllowed(analysis.categories, analysis.options.allow)) {
+          return;
+        }
+        const [first] = analysis.classifications;
+        const reportNode = analysis.classifications.find((entry) => entry.category !== first?.category)?.node ?? program;
+        context.report({
+          node: reportNode,
+          messageId: "mixedSemanticCategories",
+          data: {
+            message: buildMixedCategoriesMessage(analysis.classifications, analysis.options.debug)
+          }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/index.ts
 var rules = {
   "barrel-purity": barrelPurityRule,
@@ -802,12 +1379,13 @@ var rules = {
   "filename-matches-export": filenameMatchesExportRule,
   "index-must-reexport-default": indexMustReexportDefaultRule,
   "max-import-depth": maxImportDepthRule,
-  "no-cross-feature-imports": noCrossFeatureImportsRule
+  "no-cross-feature-imports": noCrossFeatureImportsRule,
+  "single-semantic-module": singleSemanticModuleRule
 };
 
 // src/index.ts
 var NAMESPACE = "noctcore-architecture";
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 var plugin = {
   meta: { name: "@noctcore/eslint-plugin-architecture", version: VERSION },
   rules,

package/dist/index.d.cts

@@ -1,5 +1,34 @@
 import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
 
+declare const SEMANTIC_CATEGORIES: readonly ["type", "constant", "function", "class", "react-component", "hook", "schema", "enum"];
+type SemanticCategory = (typeof SEMANTIC_CATEGORIES)[number];
+type EnumCategory = Extract<SemanticCategory, 'enum' | 'type'>;
+type SchemaLibrary = 'zod' | 'yup' | 'valibot';
+interface SingleSemanticModuleOptions {
+    /** Category sets a module may mix, e.g. `[['constant', 'type', 'enum']]`. */
+    readonly allow?: readonly (readonly SemanticCategory[])[];
+    /** Whether a TS `enum` is its own category or counts as `type`. */
+    readonly enumCategory?: EnumCategory;
+    /** List every classified declaration and why in the report. */
+    readonly debug?: boolean;
+    /** Skip `declare ...` and `declare global` blocks entirely. */
+    readonly ignoreAmbientDeclarations?: boolean;
+    /**
+     * Only the exported surface defines a module's semantics: a non-exported
+     * render helper, config object or class serves that surface and is not
+     * classified. Default true.
+     */
+    readonly ignorePrivateDeclarations?: boolean;
+    readonly schemaLibraries?: readonly SchemaLibrary[];
+    readonly reactComponentDetection?: {
+        readonly enabled?: boolean;
+    };
+    readonly hookDetection?: {
+        readonly enabled?: boolean;
+        readonly namePattern?: string;
+    };
+}
+
 interface NoCrossFeatureImportsOptions {
     readonly featureRoot?: string;
     readonly alias?: string;
@@ -58,6 +87,9 @@ declare const rules: {
     'no-cross-feature-imports': _typescript_eslint_utils_ts_eslint.RuleModule<"crossFeatureImport", [NoCrossFeatureImportsOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
         name: string;
     };
+    'single-semantic-module': _typescript_eslint_utils_ts_eslint.RuleModule<"mixedSemanticCategories", [SingleSemanticModuleOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
 };
 
 declare const plugin: {
@@ -87,6 +119,9 @@ declare const plugin: {
         'no-cross-feature-imports': _typescript_eslint_utils_ts_eslint.RuleModule<"crossFeatureImport", [NoCrossFeatureImportsOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
             name: string;
         };
+        'single-semantic-module': _typescript_eslint_utils_ts_eslint.RuleModule<"mixedSemanticCategories", [SingleSemanticModuleOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
     };
     configs: Record<string, unknown>;
 };