@rsdk/depdoc.cli 6.0.0-next.43 → 6.0.0-next.45

package/src/model/config-validation.ts

@@ -1,9 +1,13 @@
 /**
  * Config validation for rule shapes that the model cannot interpret safely.
  */
-import type { DependencyModelConfig, DependencyRule } from './types';
+import type {
+  DependencyModelConfig,
+  DependencyRule,
+  ToolingFileRule,
+} from './types';
 
-function getRuleMatches(rule: DependencyRule): string[] {
+function getRuleMatches(rule: DependencyRule | ToolingFileRule): string[] {
   return Array.isArray(rule.match) ? rule.match : [rule.match];
 }
 
@@ -47,12 +51,51 @@ export function validateIgnoredImports(ignoredImports: unknown): string[] {
   );
 }
 
+function isStringOrStringArray(value: unknown): boolean {
+  return (
+    typeof value === 'string' ||
+    (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+  );
+}
+
+export function validateToolingFiles(toolingFiles: unknown): string[] {
+  if (toolingFiles === undefined) return [];
+  if (!Array.isArray(toolingFiles)) {
+    return ['toolingFiles must be an array of { match, workspace? } rules'];
+  }
+
+  return toolingFiles.flatMap((item, index) => {
+    const label = `toolingFiles[${index}]`;
+    if (typeof item !== 'object' || item === null) {
+      return [`${label} must be an object with a match field`];
+    }
+
+    const rule = item as Record<string, unknown>;
+    const errors: string[] = [];
+
+    if (!isStringOrStringArray(rule.match)) {
+      errors.push(`${label}.match must be a string or an array of strings`);
+    }
+    if (
+      rule.workspace !== undefined &&
+      !isStringOrStringArray(rule.workspace)
+    ) {
+      errors.push(
+        `${label}.workspace must be a string or an array of strings`,
+      );
+    }
+
+    return errors;
+  });
+}
+
 export function assertValidDependencyModelConfig(
   config: DependencyModelConfig,
 ): void {
   const errors = [
     ...validateDependencyRules(config.rules ?? []),
     ...validateIgnoredImports(config.ignoredImports),
+    ...validateToolingFiles(config.toolingFiles),
   ];
 
   if (errors.length === 0) return;

package/src/model/diagnostics.ts

@@ -258,7 +258,12 @@ export function validateBasicShape(
       });
     }
 
-    if (workspace.hasSrc && !workspace.hasDist && withDts) {
+    if (
+      workspace.role === 'library' &&
+      workspace.hasSrc &&
+      !workspace.hasDist &&
+      withDts
+    ) {
       violations.push({
         code: 'dist-missing',
         workspace: getWorkspaceLabel(workspace),

package/src/model/placement.ts

@@ -27,6 +27,20 @@ function isTestFile(file: string): boolean {
   );
 }
 
+// Build-tool config files (vite.config.ts, eslint.config.js, ...) import
+// real packages, but those imports are tooling usage, not the workspace's
+// own runtime surface — treat them like test files for placement purposes
+// so they don't get forced into dependencies/peerDependencies. Matched by
+// exact path against the workspace's collected tooling files (not by name
+// pattern), so an app module that merely happens to be named e.g.
+// src/auth.config.ts is never misclassified.
+function isPrivateUsageFile(
+  file: string,
+  toolingFiles: ReadonlySet<string>,
+): boolean {
+  return isTestFile(file) || toolingFiles.has(file);
+}
+
 export function isExternal(
   depIdent: string,
   workspaceNames: Set<string>,
@@ -215,9 +229,13 @@ export function addUsageDependencies(
     const workspace = expected.workspace;
     if (workspace.isRoot) continue;
 
+    const toolingFiles = workspace.toolingFiles ?? new Set<string>();
+
     for (const [depIdent, usage] of workspace.sourceUsage) {
       const publicType = workspace.dtsImports.has(depIdent);
-      const runtime = [...usage.runtimeFiles].some((file) => !isTestFile(file));
+      const runtime = [...usage.runtimeFiles].some(
+        (file) => !isPrivateUsageFile(file, toolingFiles),
+      );
       const allTestOnly = [...usage.files].every(isTestFile);
 
       if (runtime || publicType) {

package/src/model/types.ts

@@ -23,9 +23,18 @@ export interface DependencyRule {
   required?: boolean;
 }
 
+// Extra root-level filename patterns (beyond the built-in *.config.* suffix
+// convention) whose imports should be treated as tooling usage rather than
+// the workspace's own runtime surface, e.g. Docusaurus' sidebars.ts.
+export interface ToolingFileRule {
+  match: string | string[];
+  workspace?: string | string[];
+}
+
 export interface DependencyModelConfig {
   version?: number;
   ignoredImports?: string[];
+  toolingFiles?: ToolingFileRule[];
   rules?: DependencyRule[];
   doctor?: DoctorConfig;
 }
@@ -95,6 +104,11 @@ export interface WorkspaceFacts {
   hasSrc: boolean;
   hasDist: boolean;
   sourceFileCount?: number;
+
+  // Absolute paths of build-tool config files (vite.config.ts, ...) collected
+  // for this workspace; their imports are tooling usage, not the workspace's
+  // own runtime surface. Optional so callers that predate this field compile.
+  toolingFiles?: Set<string>;
 }
 
 export interface WorkspaceContext extends WorkspaceFacts {

package/src/runner.ts

@@ -37,6 +37,7 @@ export function runDependencyModel(
     rootDir,
     withDts,
     config.ignoredImports ?? [],
+    config.toolingFiles ?? [],
   );
   const packageExtensions = loadPackageExtensions(rootDir);
   const workspaceNames = new Set(