init

马宇豪

2024-07-16 f591c27b57e2418c9495bc02ae8cfff84d35bc18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getExtensionDescription = exports.ExplorerBase = void 0;
const env_paths_1 = __importDefault(require("env-paths"));
const os_1 = __importDefault(require("os"));
const path_1 = __importDefault(require("path"));
const util_js_1 = require("./util.js");
/**
 * @internal
 */
class ExplorerBase {
    #loadingMetaConfig = false;
    config;
    loadCache;
    searchCache;
    constructor(options) {
        this.config = options;
        if (options.cache) {
            this.loadCache = new Map();
            this.searchCache = new Map();
        }
        this.#validateConfig();
    }
    set loadingMetaConfig(value) {
        this.#loadingMetaConfig = value;
    }
    #validateConfig() {
        const config = this.config;
        for (const place of config.searchPlaces) {
            const extension = path_1.default.extname(place);
            const loader = this.config.loaders[extension || 'noExt'] ??
                this.config.loaders['default'];
            if (loader === undefined) {
                throw new Error(`Missing loader for ${getExtensionDescription(place)}.`);
            }
            if (typeof loader !== 'function') {
                throw new Error(`Loader for ${getExtensionDescription(place)} is not a function: Received ${typeof loader}.`);
            }
        }
    }
    clearLoadCache() {
        if (this.loadCache) {
            this.loadCache.clear();
        }
    }
    clearSearchCache() {
        if (this.searchCache) {
            this.searchCache.clear();
        }
    }
    clearCaches() {
        this.clearLoadCache();
        this.clearSearchCache();
    }
    toCosmiconfigResult(filepath, config) {
        if (config === null) {
            return null;
        }
        if (config === undefined) {
            return { filepath, config: undefined, isEmpty: true };
        }
        if (this.config.applyPackagePropertyPathToConfiguration ||
            this.#loadingMetaConfig) {
            const packageProp = this.config.packageProp ?? this.config.moduleName;
            config = (0, util_js_1.getPropertyByPath)(config, packageProp);
        }
        if (config === undefined) {
            return { filepath, config: undefined, isEmpty: true };
        }
        return { config, filepath };
    }
    validateImports(containingFilePath, imports, importStack) {
        const fileDirectory = path_1.default.dirname(containingFilePath);
        for (const importPath of imports) {
            if (typeof importPath !== 'string') {
                throw new Error(`${containingFilePath}: Key $import must contain a string or a list of strings`);
            }
            const fullPath = path_1.default.resolve(fileDirectory, importPath);
            if (fullPath === containingFilePath) {
                throw new Error(`Self-import detected in ${containingFilePath}`);
            }
            const idx = importStack.indexOf(fullPath);
            if (idx !== -1) {
                throw new Error(`Circular import detected:
${[...importStack, fullPath]
                    .map((path, i) => `${i + 1}. ${path}`)
                    .join('\n')} (same as ${idx + 1}.)`);
            }
        }
    }
    getSearchPlacesForDir(dir, globalConfigPlaces) {
        return (dir.isGlobalConfig ? globalConfigPlaces : this.config.searchPlaces).map((place) => path_1.default.join(dir.path, place));
    }
    getGlobalConfigDir() {
        return (0, env_paths_1.default)(this.config.moduleName, { suffix: '' }).config;
    }
    *getGlobalDirs(startDir) {
        const stopDir = path_1.default.resolve(this.config.stopDir ?? os_1.default.homedir());
        yield { path: startDir, isGlobalConfig: false };
        let currentDir = startDir;
        while (currentDir !== stopDir) {
            const parentDir = path_1.default.dirname(currentDir);
            /* istanbul ignore if -- @preserve */
            if (parentDir === currentDir) {
                // we're probably at the root of the directory structure
                break;
            }
            yield { path: parentDir, isGlobalConfig: false };
            currentDir = parentDir;
        }
        yield { path: this.getGlobalConfigDir(), isGlobalConfig: true };
    }
}
exports.ExplorerBase = ExplorerBase;
/**
 * @internal
 */
function getExtensionDescription(extension) {
    /* istanbul ignore next -- @preserve */
    return extension ? `extension "${extension}"` : 'files without extensions';
}
exports.getExtensionDescription = getExtensionDescription;
//# sourceMappingURL=ExplorerBase.js.map