@ts-for-gir/cli/lib/module-loader.d.ts

TypeScript type definition generator for GObject introspection GIR files

/**
 * The ModuleLoader is used for reading gir modules from the file system and to solve conflicts (e.g. Gtk-3.0 and Gtk-4.0 would be a conflict)
 */
import { type Question } from 'inquirer';
import { DependencyManager, ResolveType, GirModule, Logger } from '@ts-for-gir/lib';
import type { GirModulesGroupedMap, OptionsGeneration, GirModuleResolvedBy, GirModulesGrouped, DependencyMap, Dependency, AnswerVersion } from '@ts-for-gir/lib';
export declare class ModuleLoader {
    protected readonly config: OptionsGeneration;
    log: Logger;
    dependencyManager: DependencyManager;
    /** Transitive module dependencies */
    modDependencyMap: DependencyMap;
    constructor(config: OptionsGeneration);
    /**
     * Groups Gir modules by name id
     * E.g. Gtk-3.0 and Gtk-4.0 will be grouped
     * @param girFiles
     */
    protected groupGirFiles(resolveGirModules: Set<GirModuleResolvedBy> | GirModuleResolvedBy[]): GirModulesGroupedMap;
    /**
     * Sorts out the module the user has not selected via cli prompt
     * @param girModulesGrouped
     * @param selected Users selected module packageName
     */
    protected sortVersionsByAnswer(girModulesGrouped: GirModulesGrouped, selected: string[]): {
        keep: Set<GirModuleResolvedBy>;
        ignore: string[];
    };
    protected generateContinueQuestion(message?: string, choices?: string[]): {
        message: string;
        choices: string[];
    };
    protected generateIgnoreDepsQuestion(message?: string, choices?: string[]): {
        message: string;
        choices: string[];
    };
    protected askIgnoreDepsPrompt(deps: GirModuleResolvedBy[] | Set<GirModuleResolvedBy>): Promise<'Yes' | 'No' | 'Go back'>;
    /**
     * Ask for duplicates / multiple versions of a module
     * @param girModuleGrouped
     * @param message
     */
    protected generateModuleVersionQuestion(girModuleGrouped: GirModulesGrouped, message?: string): Question;
    /**
     * Find modules that depend on the module with the name 'packageName'
     * @param girModulesGroupedMap
     * @param packageName
     */
    protected findGirFilesDependOnPackage(girModulesGroupedMap: GirModulesGroupedMap, packageName: string): GirModuleResolvedBy[];
    /**
     * Find modules that depend on the module with the names in `packageNames`
     * @param girModulesGroupedMap
     * @param packageName
     */
    protected findGirFilesDependOnPackages(girModulesGroupedMap: GirModulesGroupedMap, packageNames: string[]): GirModuleResolvedBy[];
    protected askForVersionsPrompt(girModulesGrouped: GirModulesGrouped): Promise<AnswerVersion>;
    /**
     * If multiple versions of the same module are found, this will aks the user with input prompts for the version he wish to use.
     * Ignores also modules that depend on a module that should be ignored
     * @param resolveFirModules
     */
    protected askForEachConflictVersionsPrompt(girModulesGroupedMap: GirModulesGroupedMap, ignore: string[]): Promise<{
        keep: Set<GirModuleResolvedBy>;
        ignore: string[];
    }>;
    /**
     * Asks via cli prompt if the user wants to add the ignored modules to his config file
     * @param ignoredModules
     */
    protected askAddToIgnoreToConfigPrompt(ignoredModules: string[] | Set<string>): Promise<void>;
    /**
     * Figure out transitive module dependencies
     * @param packageName
     * @param result
     */
    protected traverseDependencies(packageName: string, result?: {
        [name: string]: Dependency;
    }): void;
    /**
     * Extends the modDependencyMap by the current Module,
     * should be called for each girModule so that the modDependencyMap is complete
     * @param girModule
     */
    protected extendDependencyMapByGirModule(girModule: GirModule): void;
    /**
     * Sets the traverse dependencies for the current girModule,
     * is required so that all dependencies can be found internally when generating the dependency imports for the module .d.ts file
     * @param girModules
     */
    protected initGirModules(girModules: GirModuleResolvedBy[]): Promise<void>;
    /**
     * Reads a gir xml module file and creates an object of GirModule.
     * Also sets the setDependencyMap
     * @param fillName
     * @param config
     */
    protected loadAndCreateGirModule(dependency: Dependency): Promise<GirModule | null>;
    /**
     * Returns a girModule found by `packageName` property
     * @param girModules Array of girModules
     * @param packageNames Full name like 'Gtk-3.0' you are looking for
     */
    protected findGirModuleByFullNames(girModules: (GirModuleResolvedBy | GirModule)[], packageNames: string[]): Array<GirModuleResolvedBy | GirModule>;
    /**
     * Checks if a girModules with the `packageNames` exists
     * @param girModules
     * @param packageName
     */
    protected existsGirModules(girModules: (GirModuleResolvedBy | GirModule)[], packageName: string): boolean;
    /**
     *  Reads the gir xml module files and creates an object of GirModule for each module
     * @param dependencies
     * @param girModules
     * @param resolvedBy
     * @param failedGirModules
     * @param ignoreDependencies
     * @returns
     */
    protected loadGirModules(dependencies: Dependency[], ignoreDependencies?: string[], girModules?: GirModuleResolvedBy[], resolvedBy?: ResolveType, failedGirModules?: Set<string>): Promise<{
        loaded: GirModuleResolvedBy[];
        failed: Set<string>;
    }>;
    /**
     * Find modules with the possibility to use wild cards for module names. E.g. `Gtk*` or `'*'`
     * @param modules
     * @param ignore
     */
    protected findGirFiles(globPackageNames: string[], ignore?: string[]): Promise<Set<string>>;
    protected girFilePathToDependencies(girFiles: Set<string>): Promise<Dependency[]>;
    /**
     * Loads all found `packageNames`
     * @param girDirectories
     * @param packageNames
     * @param doNotAskForVersionOnConflict Set this to false if you want to get a prompt for each version conflict
     */
    getModulesResolved(packageNames: string[], ignore?: string[], doNotAskForVersionOnConflict?: boolean): Promise<{
        keep: GirModuleResolvedBy[];
        grouped: GirModulesGroupedMap;
        ignore: string[];
        failed: Set<string>;
    }>;
    /**
     * Find modules
     * @param girDirectories
     * @param modules
     */
    getModules(modules: string[], ignore?: string[]): Promise<{
        grouped: GirModulesGroupedMap;
        loaded: GirModuleResolvedBy[];
        failed: string[];
    }>;
    /** Start parsing the gir modules */
    parse(girModules: GirModuleResolvedBy[]): void;
}