@alint-js/core 0.0.5 → 0.0.6

package/dist/index.d.mts

@@ -34,21 +34,38 @@ interface SetupModelDefinition {
 }
 //#endregion
 //#region src/core/source/types.d.ts
-interface ClassUnit extends SourceUnit {
-  exported: boolean;
-  kind: 'class';
-}
-interface FunctionUnit extends SourceUnit {
-  async: boolean;
-  exported: boolean;
-  kind: 'function';
+interface LanguageContext {
+  cwd: string;
+  languageOptions: Record<string, unknown>;
+  src: SourceRuntime;
 }
 interface LineRange {
   endLine: number;
   startLine: number;
 }
+interface ProcessedSource {
+  identity: string;
+  language?: string;
+  origin?: ProcessedSourceOrigin;
+  path: string;
+  text: string;
+}
+interface ProcessedSourceOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface ProcessorContext {
+  cwd: string;
+  options: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface ProcessorPostprocessContext extends ProcessorContext {
+  file: SourceFile;
+  processedSources: ProcessedSource[];
+}
 interface SourceFile {
-  language: 'javascript' | 'typescript' | 'unknown';
+  language: string;
   lines: string[];
   path: string;
   text: string;
@@ -66,22 +83,32 @@ interface SourceRange {
   start: number;
 }
 interface SourceRuntime {
-  getText: (target: SourceFile | SourceUnit) => string;
+  getText: (target: SourceFile | SourceTarget) => string;
   readFile: (filePath: string) => Promise<SourceFile>;
   sliceLines: (file: SourceFile, range: LineRange) => SourceText;
   sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
 }
-interface SourceText {
-  filePath: string;
-  loc: SourceLocation;
+interface SourceTarget {
+  file: SourceFile;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: Record<string, unknown>;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
   text: string;
 }
-interface SourceUnit {
-  file: SourceFile;
-  kind: 'class' | 'function';
+type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
+interface SourceTargetOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface SourceText {
+  filePath: string;
   loc: SourceLocation;
-  name?: string;
-  range: SourceRange;
   text: string;
 }
 //#endregion
@@ -115,11 +142,28 @@ interface ResolveModelOptions {
 }
 //#endregion
 //#region src/dsl/types.d.ts
-interface AlintConfig {
+type AlintConfig = readonly AlintConfigInput[];
+type AlintConfigExtends = AlintConfigInput | string;
+type AlintConfigInput = AlintConfigItem | readonly AlintConfigInput[];
+interface AlintConfigItem {
+  basePath?: string;
+  extends?: readonly AlintConfigExtends[];
+  files?: readonly (readonly string[] | string)[];
   ignore?: IgnoreConfig;
-  plugins?: PluginDefinition[];
+  ignores?: readonly string[];
+  language?: string;
+  languageOptions?: Record<string, unknown>;
+  linterOptions?: AlintLinterOptions;
+  name?: string;
+  plugins?: Record<string, PluginDefinition>;
+  processor?: ProcessorDefinition | string;
   rules?: Record<string, RuleConfigEntry>;
   runner?: RunnerConfig;
+  settings?: Record<string, unknown>;
+}
+interface AlintLinterOptions {
+  noInlineConfig?: boolean;
+  reportUnusedDisableDirectives?: RuleSeverity;
 }
 type Awaitable<T> = Promise<T> | T;
 interface DiagnosticDescriptor {
@@ -142,15 +186,25 @@ interface EnabledRule {
   id: string;
   localId: string;
   rule: RuleDefinition;
-  scope: string;
   severity: Exclude<RuleSeverity, 'off'>;
 }
 interface IgnoreConfig {
   gitignore?: boolean;
 }
+interface LanguageDefinition {
+  extensions?: readonly string[];
+  extract: (file: SourceFile, context: LanguageContext) => Awaitable<SourceTarget[]>;
+  name: string;
+}
 interface PluginDefinition {
-  rules: Record<string, RuleDefinition>;
-  scope: string;
+  configs?: Record<string, AlintConfigInput>;
+  languages?: Record<string, LanguageDefinition>;
+  processors?: Record<string, ProcessorDefinition>;
+  rules?: Record<string, RuleDefinition>;
+}
+interface ProcessorDefinition {
+  postprocess?: (diagnostics: DiagnosticDescriptor[], context: ProcessorPostprocessContext) => Awaitable<DiagnosticDescriptor[]>;
+  preprocess: (file: SourceFile, context: ProcessorContext) => Awaitable<ProcessedSource[]>;
 }
 type RuleCacheConfig = boolean | {
   level?: 'target';
@@ -168,7 +222,7 @@ interface RuleContext {
   };
   model: (selector?: ModelRequirement | string) => Promise<ResolvedModel>;
   report: (diagnostic: DiagnosticDescriptor) => void;
-  scope: string;
+  settings: Record<string, unknown>;
   src: SourceRuntime;
 }
 interface RuleDefinition {
@@ -177,9 +231,7 @@ interface RuleDefinition {
   model?: ModelRequirement;
 }
 interface RuleHandlers {
-  onClass?: (classNode: ClassUnit) => Awaitable<void>;
-  onFile?: (file: SourceFile) => Awaitable<void>;
-  onFunction?: (functionNode: FunctionUnit) => Awaitable<void>;
+  onTarget?: (target: SourceTarget) => Awaitable<void>;
 }
 interface RuleInferenceUsageRecord {
   filePath?: string;
@@ -197,6 +249,54 @@ interface RuleRegistry {
 }
 type RuleSeverity = 'error' | 'off' | 'warn';
 //#endregion
+//#region src/config/config-array.d.ts
+interface EffectiveAlintConfig {
+  language?: string;
+  languageOptions: Record<string, unknown>;
+  linterOptions: Record<string, unknown>;
+  plugins: Record<string, PluginDefinition>;
+  processor?: AlintConfigItem['processor'];
+  rules: Record<string, RuleConfigEntry>;
+  runner?: AlintConfigItem['runner'];
+  settings: Record<string, unknown>;
+}
+interface ResolveConfigOptions {
+  cwd: string;
+}
+interface ResolveConfigResult {
+  config: EffectiveAlintConfig;
+  ignored: boolean;
+  matched: AlintConfigItem[];
+  skipped: Array<{
+    item: AlintConfigItem;
+    reason: string;
+  }>;
+}
+declare function hasDiscoveryFilePatterns(input: AlintConfig): boolean;
+declare function matchesDiscoveryFile(filePath: string, input: AlintConfig, options: ResolveConfigOptions): boolean;
+declare function normalizeConfig(input: readonly AlintConfigInput[]): AlintConfigItem[];
+declare function resolveConfigForFile(filePath: string, input: AlintConfig, options: ResolveConfigOptions): ResolveConfigResult;
+//#endregion
+//#region src/core/languages/registry.d.ts
+interface LanguageRegistry {
+  byExtension: Map<string, string>;
+  languages: Map<string, LanguageDefinition>;
+}
+declare function registerLanguage(registry: LanguageRegistry, language: LanguageDefinition): void;
+//#endregion
+//#region src/core/languages/resolve.d.ts
+interface ResolveLanguageOptions {
+  language?: string;
+  processedLanguage?: string;
+}
+declare function resolveLanguage(file: SourceFile, registry: LanguageRegistry, options: ResolveLanguageOptions): LanguageDefinition;
+//#endregion
+//#region src/core/languages/index.d.ts
+declare function createBuiltInLanguageRegistry(): LanguageRegistry;
+//#endregion
+//#region src/core/languages/js/extract.d.ts
+declare function extractJsSourceTargets(file: SourceFile): SourceTarget[];
+//#endregion
 //#region src/core/types.d.ts
 interface Diagnostic {
   evidence?: unknown;
@@ -256,7 +356,7 @@ interface ProgressReporter {
   onTargetStart?: (payload: TargetProgressPayload) => void;
   onUsage?: (payload: UsageProgressPayload) => void;
 }
-type ProgressTargetKind = 'class' | 'file' | 'function';
+type ProgressTargetKind = SourceTargetKind;
 interface RuleEndPayload {
   cache: 'hit' | 'miss';
   endedAt?: number;
@@ -338,13 +438,6 @@ declare class AlintRunError extends Error {
 }
 declare function runAlint(options?: RunOptions): Promise<RunResult>;
 //#endregion
-//#region src/core/source/js.d.ts
-interface JsSourceUnits {
-  classes: ClassUnit[];
-  functions: FunctionUnit[];
-}
-declare function extractJsSourceUnits(file: SourceFile): JsSourceUnits;
-//#endregion
 //#region src/core/source/runtime.d.ts
 declare function createSourceFile(path: string, text: string): SourceFile;
 declare function createSourceRuntime(): SourceRuntime;
@@ -352,14 +445,14 @@ declare function sliceLines(file: SourceFile, range: LineRange): SourceText;
 declare function sliceRange(file: SourceFile, range: SourceRange): SourceText;
 //#endregion
 //#region src/dsl/define.d.ts
-declare function defineConfig(config: AlintConfig): AlintConfig;
+declare function defineConfig(config: readonly AlintConfigInput[]): AlintConfig;
 declare function definePlugin(plugin: PluginDefinition): PluginDefinition;
 declare function defineRule(rule: RuleDefinition): RuleDefinition;
 //#endregion
 //#region src/dsl/registry.d.ts
-declare function buildRuleRegistry(config: AlintConfig): RuleRegistry;
+declare function buildRuleRegistry(config: Pick<EffectiveAlintConfig, 'plugins' | 'rules'>): RuleRegistry;
 //#endregion
 //#region src/models/resolve.d.ts
 declare function resolveModel(registry: SetupConfig, options?: ResolveModelOptions): ResolvedModel;
 //#endregion
-export { type AlintConfig, AlintRunError, type Awaitable, type ClassUnit, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type EnabledRule, type FileProgressPayload, type FunctionUnit, type IgnoreConfig, type InferenceUsageRecord, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProviderDefinition, type ProviderType, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleStartPayload, type RunEndPayload, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunnerConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceText, type SourceUnit, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceUnits, resolveModel, runAlint, sliceLines, sliceRange };
+export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunError, type Awaitable, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type EffectiveAlintConfig, type EnabledRule, type FileProgressPayload, type IgnoreConfig, type InferenceUsageRecord, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleStartPayload, type RunEndPayload, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunnerConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOrigin, type SourceText, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForFile, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };