language

type Builder[F CodeFile, C any] func(C) (Language[F], error)

type CodeFile interface {
	Loc() int
	Size() int
}

type Config interface {
	UnwrapProxyExports() bool
	IgnoreFiles() []string
}

type ExportEntry struct {
	// All: all the names from Path are exported.
	All bool
	// Names: exported specific names from Path.
	Names []ExportName
	// Path: absolute path from where they are exported, it might be from the same file or from another.
	Path string
}

type ExportName struct {
	Original string
	Alias    string
}

type ExportsEntries struct {
	// Exports: array of ExportEntry
	//  NOTE: even though it could work returning a path relative to the file, it should return absolute.
	Exports []ExportEntry
	// Errors: errors while parsing exports.
	Errors []error
}

type ExportsResult struct {
	// Exports: map from exported name to exported path.
	Exports *orderedmap.OrderedMap[string, string]
	// Errors: errors gathered while resolving exports.
	Errors []error
}

type FileCacheKey string

type FileInfo struct {
	Loc  int
	Size int
}

type Graph = graph.Graph[FileInfo]

type ImportEntry struct {
	// All: if all the names from Path are imported.
	All bool
	// Names: what specific names form Path are imported.
	Names []string
	// Path: from where are the names imported.
	Path string
}

type ImportsCacheKey string

type ImportsResult struct {
	// Imports: ordered map from absolute imported path to the array of names that where imported.
	//  if one of the names is *, then all the names are imported
	Imports []ImportEntry
	// Errors: errors while parsing imports.
	Errors []error
}

type Language[F CodeFile] interface {
	// ParseFile receives an absolute file path and returns F, where F is the specific file implementation
	//  defined by the language. This file object F will be used as input for parsing imports and exports.
	ParseFile(path string) (*F, error)
	// ParseImports receives the file F parsed by the ParseFile method and gathers the imports that the file
	//  F contains.
	ParseImports(file *F) (*ImportsResult, error)
	// ParseExports receives the file F parsed by the ParseFile method and gathers the exports that the file
	//  F contains.
	ParseExports(file *F) (*ExportsEntries, error)
	// Display takes an absolute path to a file and displays it nicely.
	Display(path string) string
}

type Node = graph.Node[FileInfo]

type NodeParser = dep_tree.NodeParser[FileInfo]

type NodeParserBuilder = dep_tree.NodeParserBuilder[FileInfo]

type Parser[F CodeFile] struct {
	// contains filtered or unexported fields
}

type TestFile struct {
	Name string
}

type TestLanguage struct {
	// contains filtered or unexported fields
}