module

type Cache interface {
	// Get 获取缓存的模块
	Get(path string) (*Module, bool)

	// Set 设置缓存的模块
	Set(path string, module *Module)

	// Clear 清空缓存
	Clear()

	// Remove 移除指定模块
	Remove(path string)
}

type ExportProcessor interface {
	// ProcessExport 处理导出声明
	ProcessExport(exportDecl *ast.ExportDecl, modulePath string) (*Rule, error)

	// ValidateExport 验证导出声明
	ValidateExport(exportDecl *ast.ExportDecl) error

	// GetExportedRule 获取导出的规则
	GetExportedRule(name string, exports map[string]*Rule) (*Rule, error)
}

type ImportProcessor interface {
	// ProcessImport 处理导入声明
	ProcessImport(basePath string, importDecl *ast.ImportDecl, loader Loader) (*ImportedModule, error)

	// ValidateImport 验证导入声明
	ValidateImport(importDecl *ast.ImportDecl) error

	// ResolveImportedRule 解析导入的规则
	ResolveImportedRule(localName string, importedMod *ImportedModule) (*Rule, error)
}

type ImportedModule struct {
	Source     string            // 源路径
	Module     *Module           // 导入的模块
	Specifiers map[string]string // 导入项映射 (local -> imported)
}

type Loader interface {
	// Load 加载模块
	Load(path string) (*Module, error)

	// LoadFromSource 从源代码加载模块
	LoadFromSource(path, source string) (*Module, error)

	// GetCache 获取缓存
	GetCache() Cache

	// ClearCache 清空缓存
	ClearCache()
}

type Module struct {
	Path    string            // 模块路径
	Program *ast.Program      // 解析后的 AST
	Exports map[string]*Rule  // 导出的规则
	Imports []*ImportedModule // 导入的模块
}

type Resolver interface {
	// Resolve 解析模块路径
	// basePath: 当前模块的路径
	// importPath: 要导入的路径
	// 返回: 解析后的绝对路径
	Resolve(basePath, importPath string) (string, error)
}

type Rule struct {
	Name       string        // 规则名称
	Decl       *ast.RuleDecl // 规则声明
	ModulePath string        // 所属模块路径
}