seniority/cosmiconfig

import { cosmiconfig, cosmiconfigSync, Explorer, … } from 'seniority/cosmiconfig';

function cosmiconfig(moduleName: string, options?: Readonly<Partial<Options>>): PublicExplorer;

function cosmiconfigSync(moduleName: string, options?: Readonly<Partial<OptionsSync>>): PublicExplorerSync;

class Explorer extends ExplorerBase {
    load(filepath: string): Promise<CosmiconfigResult>;
    search(from?: string): Promise<CosmiconfigResult>;
    /** A `metaConfigFilePath` that loads to something non-empty short-circuits the whole search. */
    private searchMetaConfig;
    /** One directory's places, in order; `undefined` means "nothing here, keep walking". Untransformed. */
    private scan;
    private readConfiguration;
    private loadWithImports;
    private loadConfiguration;
    private directories;
}

class ExplorerSync extends ExplorerBase {
    load(filepath: string): CosmiconfigResult;
    search(from?: string): CosmiconfigResult;
    private searchMetaConfig;
    private scan;
    private readConfiguration;
    private loadWithImports;
    private loadConfiguration;
    private directories;
}

interface CommonOptions {
    packageProp?: string | string[];
    searchPlaces: string[];
    ignoreEmptySearchPlaces: boolean;
    stopDir?: string;
    cache: boolean;
    mergeImportArrays: boolean;
    mergeSearchPlaces: boolean;
    searchStrategy: SearchStrategy;
    /**
     * seniority's one addition: the directory a `global` search ends in. cosmiconfig derives it
     * from the environment through `env-paths`; this package takes it as an argument so nothing
     * here reads `process.*` (R11), and defaults it from `os.homedir()` and the platform.
     */
    globalConfigDir?: string;
}

interface Options extends CommonOptions {
    loaders: Loaders;
    transform: Transform;
}

interface PublicExplorer {
    search: (from?: string) => Promise<CosmiconfigResult>;
    load: (filepath: string) => Promise<CosmiconfigResult>;
    clearLoadCache: () => void;
    clearSearchCache: () => void;
    clearCaches: () => void;
}

interface PublicExplorerSync {
    search: (from?: string) => CosmiconfigResult;
    load: (filepath: string) => CosmiconfigResult;
    clearLoadCache: () => void;
    clearSearchCache: () => void;
    clearCaches: () => void;
}

type Config = unknown;

type CosmiconfigResult = {
    config: Config;
    filepath: string;
    isEmpty?: boolean;
} | null;

type Loaders = Record<string, Loader>;

type OptionsSync = Options;

type SearchStrategy = 'none' | 'project' | 'global';

type Transform = (result: CosmiconfigResult) => CosmiconfigResult | Promise<CosmiconfigResult>;