react-doctor 0.1.6 → 0.2.0-beta.0

package/dist/compat.d.ts

@@ -0,0 +1,53 @@
+import { b as isReactDoctorError, c as ReactDoctorError, f as ReactDoctorNoReactDependencyError, h as ReactDoctorProjectNotFoundError, p as ReactDoctorPackageJsonNotFoundError, t as ReactDoctorAmbiguousProjectError } from "./errors-ZdckckLr.js";
+
+//#region src/sdk/compat.d.ts
+interface Diagnostic {
+  filePath: string;
+  plugin: string;
+  rule: string;
+  severity: "error" | "warning";
+  message: string;
+  help: string;
+  url?: string;
+  line: number;
+  column: number;
+  category: string;
+  suppressionHint?: string;
+}
+interface ScoreResult {
+  score: number;
+  label: string;
+}
+interface ProjectInfo {
+  rootDirectory: string;
+  projectName: string;
+  reactVersion: string | null;
+  tailwindVersion: string | null;
+  framework: string;
+  hasTypeScript: boolean;
+  hasReactCompiler: boolean;
+  hasTanStackQuery: boolean;
+  sourceFileCount: number;
+}
+interface DiagnoseOptions {
+  lint?: boolean;
+  deadCode?: boolean;
+  verbose?: boolean;
+  includePaths?: string[];
+  respectInlineDisables?: boolean;
+  signal?: AbortSignal;
+}
+interface DiagnoseResult {
+  diagnostics: Diagnostic[];
+  score: ScoreResult | null;
+  project: ProjectInfo;
+  elapsedMilliseconds: number;
+}
+/**
+ * @deprecated Use `createReactDoctor({ rootDirectory }).inspect()` from the main SDK instead.
+ */
+declare const diagnose: (directory: string, options?: DiagnoseOptions) => Promise<DiagnoseResult>;
+declare const clearCaches: () => void;
+//#endregion
+export { ReactDoctorAmbiguousProjectError as AmbiguousProjectError, DiagnoseOptions, DiagnoseResult, Diagnostic, ReactDoctorNoReactDependencyError as NoReactDependencyError, ReactDoctorPackageJsonNotFoundError as PackageJsonNotFoundError, ProjectInfo, ReactDoctorProjectNotFoundError as ProjectNotFoundError, ReactDoctorError, ScoreResult, clearCaches, diagnose, isReactDoctorError };
+//# sourceMappingURL=compat.d.ts.map

package/dist/compat.js

@@ -0,0 +1,3 @@
+import { E as ReactDoctorError, I as isReactDoctorError, O as ReactDoctorNoReactDependencyError, j as ReactDoctorProjectNotFoundError, k as ReactDoctorPackageJsonNotFoundError, y as ReactDoctorAmbiguousProjectError } from "./rules-BfZ4Ujfv.js";
+import { n as diagnose, t as clearCaches } from "./compat-CM6aj69a.js";
+export { ReactDoctorAmbiguousProjectError as AmbiguousProjectError, ReactDoctorNoReactDependencyError as NoReactDependencyError, ReactDoctorPackageJsonNotFoundError as PackageJsonNotFoundError, ReactDoctorProjectNotFoundError as ProjectNotFoundError, ReactDoctorError, clearCaches, diagnose, isReactDoctorError };

package/dist/errors-ZdckckLr.d.ts

@@ -0,0 +1,87 @@
+//#region src/core/errors.d.ts
+interface ReactDoctorErrorInfo {
+  name: string;
+  message: string;
+  code: string;
+  cause?: ReactDoctorErrorInfo;
+}
+interface ReactDoctorErrorOptions extends ErrorOptions {
+  code?: string;
+}
+declare class ReactDoctorError extends Error {
+  readonly name: string;
+  readonly code: string;
+  constructor(message: string, options?: ReactDoctorErrorOptions);
+}
+declare class ReactDoctorCancelledError extends ReactDoctorError {
+  readonly name: string;
+  constructor(message?: string, options?: ErrorOptions);
+}
+declare class ReactDoctorConfigError extends ReactDoctorError {
+  readonly name: string;
+  constructor(message: string, options?: ReactDoctorErrorOptions);
+}
+declare class ReactDoctorConfigNotFoundError extends ReactDoctorConfigError {
+  readonly name: string;
+  constructor(message?: string, options?: ErrorOptions);
+}
+declare class ReactDoctorInvalidConfigError extends ReactDoctorConfigError {
+  readonly name: string;
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class ReactDoctorProjectError extends ReactDoctorError {
+  readonly name: string;
+  readonly rootDirectory: string;
+  constructor(rootDirectory: string, message: string, options?: ReactDoctorErrorOptions);
+}
+declare class ReactDoctorProjectNotFoundError extends ReactDoctorProjectError {
+  readonly name: string;
+  constructor(rootDirectory: string, options?: ErrorOptions);
+}
+declare class ReactDoctorPackageJsonNotFoundError extends ReactDoctorProjectError {
+  readonly name: string;
+  constructor(rootDirectory: string, options?: ErrorOptions);
+}
+declare class ReactDoctorNoReactDependencyError extends ReactDoctorProjectError {
+  readonly name: string;
+  constructor(rootDirectory: string, options?: ErrorOptions);
+}
+declare class ReactDoctorAmbiguousProjectError extends ReactDoctorProjectError {
+  readonly name: string;
+  readonly candidates: readonly string[];
+  constructor(rootDirectory: string, candidates: readonly string[], options?: ErrorOptions);
+}
+declare class ReactDoctorCheckError extends ReactDoctorError {
+  readonly name: string;
+  readonly checkId: string;
+  constructor(checkId: string, message: string, options?: ReactDoctorErrorOptions);
+}
+declare class ReactDoctorCheckFailedError extends ReactDoctorCheckError {
+  readonly name: string;
+  constructor(checkId: string, message: string, options?: ErrorOptions);
+}
+declare class ReactDoctorCheckSkippedError extends ReactDoctorCheckError {
+  readonly name: string;
+  constructor(checkId: string, message: string, options?: ErrorOptions);
+}
+declare class ReactDoctorRunnerUnavailableError extends ReactDoctorCheckError {
+  readonly name: string;
+  constructor(checkId: string, message: string, options?: ErrorOptions);
+}
+declare class ReactDoctorUnsupportedRuntimeError extends ReactDoctorError {
+  readonly name: string;
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class ReactDoctorTimeoutError extends ReactDoctorError {
+  readonly name: string;
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class ReactDoctorReportError extends ReactDoctorError {
+  readonly name: string;
+  constructor(message: string, options?: ErrorOptions);
+}
+declare const isReactDoctorError: (value: unknown) => value is ReactDoctorError;
+declare const toReactDoctorErrorInfo: (error: unknown) => ReactDoctorErrorInfo;
+//#endregion
+export { ReactDoctorRunnerUnavailableError as _, ReactDoctorCheckSkippedError as a, isReactDoctorError as b, ReactDoctorError as c, ReactDoctorInvalidConfigError as d, ReactDoctorNoReactDependencyError as f, ReactDoctorReportError as g, ReactDoctorProjectNotFoundError as h, ReactDoctorCheckFailedError as i, ReactDoctorErrorInfo as l, ReactDoctorProjectError as m, ReactDoctorCancelledError as n, ReactDoctorConfigError as o, ReactDoctorPackageJsonNotFoundError as p, ReactDoctorCheckError as r, ReactDoctorConfigNotFoundError as s, ReactDoctorAmbiguousProjectError as t, ReactDoctorErrorOptions as u, ReactDoctorTimeoutError as v, toReactDoctorErrorInfo as x, ReactDoctorUnsupportedRuntimeError as y };
+//# sourceMappingURL=errors-ZdckckLr.d.ts.map

package/dist/eslint-plugin-BIjw2MeW.d.ts

@@ -0,0 +1,105 @@
+import { a as RuleContext, i as RuleVisitors } from "./index-CFzh1cBi.js";
+
+//#region src/core/rules/lint/config.d.ts
+interface OxlintRuleSeverityMap {
+  [ruleKey: string]: "error" | "warn" | "off";
+}
+declare const REACT_COMPILER_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const BUILTIN_REACT_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const BUILTIN_A11Y_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const BUILTIN_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const NEXTJS_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const REACT_NATIVE_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const TANSTACK_START_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const TANSTACK_QUERY_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const GLOBAL_REACT_DOCTOR_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const REACT_DOCTOR_CUSTOM_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const CURATED_OXLINT_RULES: OxlintRuleSeverityMap;
+declare const ALL_REACT_DOCTOR_OXLINT_RULE_KEYS: ReadonlySet<string>;
+type ReactDoctorOxlintFramework = "expo" | "nextjs" | "react" | "react-native" | "tanstack-start" | "unknown";
+interface ReactDoctorOxlintConfigOptions {
+  pluginPath: string;
+  projectRootDirectory?: string;
+  project?: ReactDoctorOxlintProjectInfo;
+  framework?: ReactDoctorOxlintFramework;
+  customRulesOnly?: boolean;
+  hasReactCompiler?: boolean;
+  hasTanStackAI?: boolean;
+  hasTanStackQuery?: boolean;
+  includeEcosystemRules?: boolean;
+  extendsPaths?: string[];
+  ignoredTags?: ReadonlySet<string>;
+}
+interface ReactDoctorOxlintProjectInfo {
+  framework?: ReactDoctorOxlintFramework;
+  hasReactCompiler?: boolean;
+  hasTanStackAI?: boolean;
+  hasTanStackQuery?: boolean;
+  hasTypeScript?: boolean;
+  reactMajorVersion?: number | null;
+  reactPeerDependencyRange?: string | null;
+  tailwindVersion?: string | null;
+}
+interface ReactDoctorOxlintJsPluginEntry {
+  name: string;
+  specifier: string;
+}
+interface ReactDoctorOxlintGeneratedConfig {
+  extends?: string[];
+  categories: Record<string, "off">;
+  plugins: string[];
+  jsPlugins: Array<string | ReactDoctorOxlintJsPluginEntry>;
+  rules: OxlintRuleSeverityMap;
+}
+declare const reactPeerRangeMinMajor: (range: string | null | undefined) => number | null;
+declare const buildReactDoctorOxlintCapabilities: (project: ReactDoctorOxlintProjectInfo) => ReadonlySet<string>;
+declare const shouldEnableReactDoctorOxlintRule: (requires: ReadonlyArray<string> | undefined, tags: ReadonlySet<string>, capabilities: ReadonlySet<string>, ignoredTags: ReadonlySet<string>) => boolean;
+declare const createReactDoctorOxlintConfig: ({
+  pluginPath,
+  projectRootDirectory,
+  project,
+  framework,
+  customRulesOnly,
+  hasReactCompiler,
+  hasTanStackAI,
+  hasTanStackQuery,
+  includeEcosystemRules,
+  extendsPaths,
+  ignoredTags
+}: ReactDoctorOxlintConfigOptions) => ReactDoctorOxlintGeneratedConfig;
+//#endregion
+//#region src/eslint-plugin.d.ts
+interface EslintRuleDefinition {
+  meta: {
+    docs: {
+      description: string;
+      recommended: boolean;
+    };
+    type: "problem" | "suggestion";
+  };
+  create: (context: RuleContext) => RuleVisitors;
+}
+interface EslintPlugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: Record<string, EslintRuleDefinition>;
+  configs: {
+    recommended: EslintFlatConfig;
+    next: EslintFlatConfig;
+    "react-native": EslintFlatConfig;
+    "tanstack-start": EslintFlatConfig;
+    "tanstack-query": EslintFlatConfig;
+    all: EslintFlatConfig;
+  };
+}
+interface EslintFlatConfig {
+  name: string;
+  plugins: Record<string, EslintPlugin>;
+  rules: OxlintRuleSeverityMap;
+}
+declare const reactDoctorEslintPlugin: EslintPlugin;
+//#endregion
+export { shouldEnableReactDoctorOxlintRule as C, reactPeerRangeMinMajor as S, ReactDoctorOxlintProjectInfo as _, BUILTIN_REACT_OXLINT_RULES as a, buildReactDoctorOxlintCapabilities as b, NEXTJS_OXLINT_RULES as c, REACT_DOCTOR_CUSTOM_OXLINT_RULES as d, REACT_NATIVE_OXLINT_RULES as f, ReactDoctorOxlintJsPluginEntry as g, ReactDoctorOxlintGeneratedConfig as h, BUILTIN_OXLINT_RULES as i, OxlintRuleSeverityMap as l, ReactDoctorOxlintFramework as m, ALL_REACT_DOCTOR_OXLINT_RULE_KEYS as n, CURATED_OXLINT_RULES as o, ReactDoctorOxlintConfigOptions as p, BUILTIN_A11Y_OXLINT_RULES as r, GLOBAL_REACT_DOCTOR_OXLINT_RULES as s, reactDoctorEslintPlugin as t, REACT_COMPILER_OXLINT_RULES as u, TANSTACK_QUERY_OXLINT_RULES as v, createReactDoctorOxlintConfig as x, TANSTACK_START_OXLINT_RULES as y };
+//# sourceMappingURL=eslint-plugin-BIjw2MeW.d.ts.map

package/dist/eslint-plugin.d.ts

@@ -1,57 +1,2 @@
-//#region src/oxlint-config.d.ts
-type RuleSeverity = "error" | "warn" | "off";
-//#endregion
-//#region src/plugin/types.d.ts
-interface RuleVisitors {
-  [selector: string]: ((node: EsTreeNode) => void) | (() => void);
-}
-interface EsTreeNode {
-  type: string;
-  [key: string]: any;
-}
-//#endregion
-//#region src/eslint-plugin.d.ts
-interface EslintRuleContext {
-  report: (descriptor: {
-    node: EsTreeNode;
-    message: string;
-  }) => void;
-  getFilename?: () => string;
-}
-interface EslintRuleMeta {
-  type: "problem" | "suggestion" | "layout";
-  docs: {
-    description: string;
-    url: string;
-    recommended: boolean;
-  };
-  schema: unknown[];
-}
-interface EslintRule {
-  meta: EslintRuleMeta;
-  create: (context: EslintRuleContext) => RuleVisitors;
-}
-interface EslintFlatConfig {
-  name: string;
-  plugins: Record<string, EslintPlugin>;
-  rules: Record<string, RuleSeverity>;
-}
-interface EslintPlugin {
-  meta: {
-    name: string;
-    version: string;
-  };
-  rules: Record<string, EslintRule>;
-  configs: {
-    recommended: EslintFlatConfig;
-    next: EslintFlatConfig;
-    "react-native": EslintFlatConfig;
-    "tanstack-start": EslintFlatConfig;
-    "tanstack-query": EslintFlatConfig;
-    all: EslintFlatConfig;
-  };
-}
-declare const eslintPlugin: EslintPlugin;
-//#endregion
-export { eslintPlugin as default };
-//# sourceMappingURL=eslint-plugin.d.ts.map
+import { t as reactDoctorEslintPlugin } from "./eslint-plugin-BIjw2MeW.js";
+export { reactDoctorEslintPlugin as default, reactDoctorEslintPlugin };