cspell-lib 6.8.1 → 6.9.0

package/dist/Settings/Controller/configLoader/configLoader.js

@@ -0,0 +1,489 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.getDefaultConfigLoader = exports.createConfigLoader = exports.clearCachedSettingsFiles = exports.getCachedFileSize = exports.getGlobalSettings = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfigSync = exports.loadConfig = exports.searchForConfigSync = exports.searchForConfig = exports.ConfigLoader = exports.defaultConfigFilenames = exports.defaultFileName = exports.sectionCSpell = void 0;
+const json = __importStar(require("comment-json"));
+const cosmiconfig_1 = require("cosmiconfig");
+const cspell_io_1 = require("cspell-io");
+const path = __importStar(require("path"));
+const vscode_uri_1 = require("vscode-uri");
+const CSpellSettingsInternalDef_1 = require("../../../Models/CSpellSettingsInternalDef");
+const logger_1 = require("../../../util/logger");
+const resolveFile_1 = require("../../../util/resolveFile");
+const constants_1 = require("../../constants");
+const CSpellSettingsServer_1 = require("../../CSpellSettingsServer");
+const GlobalSettings_1 = require("../../GlobalSettings");
+const ImportError_1 = require("../ImportError");
+const pnpLoader_1 = require("../pnpLoader");
+const normalizeRawSettings_1 = require("./normalizeRawSettings");
+const readSettings_1 = require("./readSettings");
+const supportedCSpellConfigVersions = [constants_1.configSettingsFileVersion0_2];
+const setOfSupportedConfigVersions = Object.freeze(new Set(supportedCSpellConfigVersions));
+exports.sectionCSpell = 'cSpell';
+exports.defaultFileName = 'cspell.json';
+/**
+ * Logic of the locations:
+ * - Support backward compatibility with the VS Code Spell Checker
+ *   the spell checker extension can only write to `.json` files because
+ *   it would be too difficult to automatically modify a `.js` or `.cjs` file.
+ * - To support `cspell.config.js` in a VS Code environment, have a `cspell.json` import
+ *   the `cspell.config.js`.
+ */
+const searchPlaces = Object.freeze([
+    'package.json',
+    // Original locations
+    '.cspell.json',
+    'cspell.json',
+    '.cSpell.json',
+    'cSpell.json',
+    // Original locations jsonc
+    '.cspell.jsonc',
+    'cspell.jsonc',
+    // Alternate locations
+    '.vscode/cspell.json',
+    '.vscode/cSpell.json',
+    '.vscode/.cspell.json',
+    // Standard Locations
+    'cspell.config.json',
+    'cspell.config.jsonc',
+    'cspell.config.yaml',
+    'cspell.config.yml',
+    'cspell.yaml',
+    'cspell.yml',
+    // Dynamic config is looked for last
+    'cspell.config.js',
+    'cspell.config.cjs',
+]);
+const cspellCosmiconfig = {
+    searchPlaces: searchPlaces.concat(),
+    loaders: {
+        '.json': parseJson,
+        '.jsonc': parseJson,
+    },
+};
+function parseJson(_filename, content) {
+    return json.parse(content);
+}
+exports.defaultConfigFilenames = Object.freeze(searchPlaces.concat());
+const defaultSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
+    id: 'default',
+    name: 'default',
+    version: constants_1.currentSettingsFileVersion,
+});
+const defaultPnPSettings = {};
+let defaultConfigLoader = undefined;
+class ConfigLoader {
+    /**
+     * Use `createConfigLoader`
+     * @param cspellIO - CSpellIO interface for reading files.
+     */
+    constructor(cspellIO) {
+        this.cspellIO = cspellIO;
+        this.cachedFiles = new Map();
+        this.cspellConfigExplorer = (0, cosmiconfig_1.cosmiconfig)('cspell', cspellCosmiconfig);
+        this.cspellConfigExplorerSync = (0, cosmiconfig_1.cosmiconfigSync)('cspell', cspellCosmiconfig);
+    }
+    readSettings(filename, relativeToOrDefault, defaultValue) {
+        const relativeTo = typeof relativeToOrDefault === 'string' ? relativeToOrDefault : process.cwd();
+        defaultValue = defaultValue || (typeof relativeToOrDefault !== 'string' ? relativeToOrDefault : undefined);
+        const ref = resolveFilename(filename, relativeTo);
+        return this.importSettings(ref, defaultValue, defaultValue || defaultPnPSettings);
+    }
+    getGlobalSettings() {
+        if (!this.globalSettings) {
+            const globalConf = (0, GlobalSettings_1.getRawGlobalSettings)();
+            this.globalSettings = {
+                id: 'global_config',
+                ...this.normalizeSettings(globalConf || {}, './global_config', {}),
+            };
+        }
+        return this.globalSettings;
+    }
+    clearCachedSettingsFiles() {
+        this.globalSettings = undefined;
+        this.cachedFiles.clear();
+        this.cspellConfigExplorer.clearCaches();
+        this.cspellConfigExplorerSync.clearCaches();
+    }
+    /**
+     * Read a config file and inject the fileRef.
+     * @param fileRef - filename plus context, injected into the resulting config.
+     */
+    readConfig(fileRef) {
+        // cspellConfigExplorerSync
+        const { filename, error } = fileRef;
+        if (error) {
+            fileRef.error =
+                error instanceof ImportError_1.ImportError
+                    ? error
+                    : new ImportError_1.ImportError(`Failed to read config file: "${filename}"`, error);
+            return { __importRef: fileRef };
+        }
+        const s = {};
+        try {
+            const r = this.cspellConfigExplorerSync.load(filename);
+            if (!r?.config)
+                throw new Error(`not found: "${filename}"`);
+            Object.assign(s, r.config);
+            (0, normalizeRawSettings_1.normalizeRawConfig)(s);
+            validateRawConfig(s, fileRef);
+        }
+        catch (err) {
+            fileRef.error =
+                err instanceof ImportError_1.ImportError ? err : new ImportError_1.ImportError(`Failed to read config file: "${filename}"`, err);
+        }
+        s.__importRef = fileRef;
+        return s;
+    }
+    importSettings(fileRef, defaultValues, pnpSettings) {
+        defaultValues = defaultValues ?? defaultSettings;
+        const { filename } = fileRef;
+        const importRef = { ...fileRef };
+        const cached = this.cachedFiles.get(filename);
+        if (cached) {
+            const cachedImportRef = cached.__importRef || importRef;
+            cachedImportRef.referencedBy = mergeSourceList(cachedImportRef.referencedBy || [], importRef.referencedBy);
+            cached.__importRef = cachedImportRef;
+            return cached;
+        }
+        const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
+        const name = id;
+        const finalizeSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({ id, name, __importRef: importRef });
+        this.cachedFiles.set(filename, finalizeSettings); // add an empty entry to prevent circular references.
+        const settings = { ...defaultValues, id, name, ...this.readConfig(importRef) };
+        Object.assign(finalizeSettings, this.normalizeSettings(settings, filename, pnpSettings));
+        const finalizeSrc = { name: path.basename(filename), ...finalizeSettings.source };
+        finalizeSettings.source = { ...finalizeSrc, filename };
+        this.cachedFiles.set(filename, finalizeSettings);
+        return finalizeSettings;
+    }
+    /**
+     * normalizeSettings handles correcting all relative paths, anchoring globs, and importing other config files.
+     * @param rawSettings - raw configuration settings
+     * @param pathToSettingsFile - path to the source file of the configuration settings.
+     */
+    normalizeSettings(rawSettings, pathToSettingsFile, pnpSettings) {
+        const id = rawSettings.id ||
+            [path.basename(path.dirname(pathToSettingsFile)), path.basename(pathToSettingsFile)].join('/');
+        const name = rawSettings.name || id;
+        // Try to load any .pnp files before reading dictionaries or other config files.
+        const { usePnP = pnpSettings.usePnP, pnpFiles = pnpSettings.pnpFiles } = rawSettings;
+        const pnpSettingsToUse = {
+            usePnP,
+            pnpFiles,
+        };
+        const pathToSettingsDir = path.dirname(pathToSettingsFile);
+        loadPnPSync(pnpSettingsToUse, vscode_uri_1.URI.file(pathToSettingsDir));
+        // Fix up dictionaryDefinitions
+        const settings = {
+            version: defaultSettings.version,
+            ...rawSettings,
+            id,
+            name,
+            globRoot: resolveGlobRoot(rawSettings, pathToSettingsFile),
+            languageSettings: (0, normalizeRawSettings_1.normalizeLanguageSettings)(rawSettings.languageSettings),
+        };
+        const pathToSettings = path.dirname(pathToSettingsFile);
+        const normalizedDictionaryDefs = (0, normalizeRawSettings_1.normalizeDictionaryDefs)(settings, pathToSettingsFile);
+        const normalizedSettingsGlobs = (0, normalizeRawSettings_1.normalizeSettingsGlobs)(settings, pathToSettingsFile);
+        const normalizedOverrides = (0, normalizeRawSettings_1.normalizeOverrides)(settings, pathToSettingsFile);
+        const normalizedReporters = (0, normalizeRawSettings_1.normalizeReporters)(settings, pathToSettingsFile);
+        const normalizedGitignoreRoot = (0, normalizeRawSettings_1.normalizeGitignoreRoot)(settings, pathToSettingsFile);
+        const normalizedCacheSettings = (0, normalizeRawSettings_1.normalizeCacheSettings)(settings, pathToSettingsDir);
+        const imports = typeof settings.import === 'string' ? [settings.import] : settings.import || [];
+        const source = settings.source || {
+            name: settings.name,
+            filename: pathToSettingsFile,
+        };
+        const fileSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
+            ...settings,
+            source,
+            ...normalizedDictionaryDefs,
+            ...normalizedSettingsGlobs,
+            ...normalizedOverrides,
+            ...normalizedReporters,
+            ...normalizedGitignoreRoot,
+            ...normalizedCacheSettings,
+        });
+        if (!imports.length) {
+            return fileSettings;
+        }
+        const importedSettings = imports
+            .map((name) => resolveFilename(name, pathToSettings))
+            .map((ref) => ((ref.referencedBy = [source]), ref))
+            .map((ref) => this.importSettings(ref, undefined, pnpSettingsToUse))
+            .reduce((a, b) => (0, CSpellSettingsServer_1.mergeSettings)(a, b));
+        const finalizeSettings = (0, CSpellSettingsServer_1.mergeSettings)(importedSettings, fileSettings);
+        finalizeSettings.name = settings.name || finalizeSettings.name || '';
+        finalizeSettings.id = settings.id || finalizeSettings.id || '';
+        return finalizeSettings;
+    }
+}
+exports.ConfigLoader = ConfigLoader;
+class ConfigLoaderInternal extends ConfigLoader {
+    constructor(cspellIO) {
+        super(cspellIO);
+        this._readConfig = this.readConfig.bind(this);
+        this._normalizeSettings = this.normalizeSettings.bind(this);
+    }
+    get _cachedFiles() {
+        return this.cachedFiles;
+    }
+    get _cspellConfigExplorer() {
+        return this.cspellConfigExplorer;
+    }
+    get _cspellConfigExplorerSync() {
+        return this.cspellConfigExplorerSync;
+    }
+}
+function mergeSourceList(orig, append) {
+    const collection = new Map(orig.map((s) => [s.name + (s.filename || ''), s]));
+    for (const s of append || []) {
+        const key = s.name + (s.filename || '');
+        if (!collection.has(key)) {
+            collection.set(key, s);
+        }
+    }
+    return [...collection.values()];
+}
+async function normalizeSearchForConfigResultAsync(searchPath, searchResult, pnpSettings) {
+    let result;
+    try {
+        result = (await searchResult) || undefined;
+    }
+    catch (cause) {
+        result = new ImportError_1.ImportError(`Failed to find config file at: "${searchPath}"`, cause);
+    }
+    return normalizeSearchForConfigResult(searchPath, result, pnpSettings);
+}
+function normalizeSearchForConfigResult(searchPath, searchResult, pnpSettings) {
+    const error = searchResult instanceof ImportError_1.ImportError ? searchResult : undefined;
+    const result = searchResult instanceof ImportError_1.ImportError ? undefined : searchResult;
+    const filepath = result?.filepath;
+    if (filepath) {
+        const cached = cachedFiles().get(filepath);
+        if (cached) {
+            return {
+                config: cached,
+                filepath,
+                error,
+            };
+        }
+    }
+    const { config = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({}) } = result || {};
+    const filename = result?.filepath ?? searchPath;
+    const importRef = { filename: filename, error };
+    const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
+    const name = result?.filepath ? id : `Config not found: ${id}`;
+    const finalizeSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({ id, name, __importRef: importRef });
+    const settings = { id, ...config };
+    cachedFiles().set(filename, finalizeSettings); // add an empty entry to prevent circular references.
+    Object.assign(finalizeSettings, gcl()._normalizeSettings(settings, filename, pnpSettings));
+    return {
+        config: finalizeSettings,
+        filepath,
+        error,
+    };
+}
+function searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
+    return normalizeSearchForConfigResultAsync(searchFrom || process.cwd(), cspellConfigExplorer().search(searchFrom), pnpSettings).then((r) => (r.filepath ? r.config : undefined));
+}
+exports.searchForConfig = searchForConfig;
+function searchForConfigSync(searchFrom, pnpSettings = defaultPnPSettings) {
+    let searchResult;
+    try {
+        searchResult = cspellConfigExplorerSync().search(searchFrom) || undefined;
+    }
+    catch (err) {
+        searchResult = new ImportError_1.ImportError(`Failed to find config file from: "${searchFrom}"`, err);
+    }
+    return normalizeSearchForConfigResult(searchFrom || process.cwd(), searchResult, pnpSettings).config;
+}
+exports.searchForConfigSync = searchForConfigSync;
+/**
+ * Load a CSpell configuration files.
+ * @param file - path or package reference to load.
+ * @param pnpSettings - PnP settings
+ * @returns normalized CSpellSettings
+ */
+function loadConfig(file, pnpSettings = defaultPnPSettings) {
+    const cached = cachedFiles().get(path.resolve(file));
+    if (cached) {
+        return Promise.resolve(cached);
+    }
+    return normalizeSearchForConfigResultAsync(file, cspellConfigExplorer().load(file), pnpSettings).then((r) => r.config);
+}
+exports.loadConfig = loadConfig;
+/**
+ * Load a CSpell configuration files.
+ * @param filename - path or package reference to load.
+ * @param pnpSettings - PnP settings
+ * @returns normalized CSpellSettings
+ */
+function loadConfigSync(filename, pnpSettings = defaultPnPSettings) {
+    const cached = cachedFiles().get(path.resolve(filename));
+    if (cached) {
+        return cached;
+    }
+    let searchResult;
+    try {
+        searchResult = cspellConfigExplorerSync().load(filename) || undefined;
+    }
+    catch (err) {
+        searchResult = new ImportError_1.ImportError(`Failed to find config file at: "${filename}"`, err);
+    }
+    return normalizeSearchForConfigResult(filename, searchResult, pnpSettings).config;
+}
+exports.loadConfigSync = loadConfigSync;
+function loadPnP(pnpSettings, searchFrom) {
+    if (!pnpSettings.usePnP) {
+        return Promise.resolve(undefined);
+    }
+    const loader = (0, pnpLoader_1.pnpLoader)(pnpSettings.pnpFiles);
+    return loader.load(searchFrom);
+}
+exports.loadPnP = loadPnP;
+function loadPnPSync(pnpSettings, searchFrom) {
+    if (!pnpSettings.usePnP) {
+        return undefined;
+    }
+    const loader = (0, pnpLoader_1.pnpLoader)(pnpSettings.pnpFiles);
+    return loader.loadSync(searchFrom);
+}
+exports.loadPnPSync = loadPnPSync;
+function readRawSettings(filename, relativeTo) {
+    relativeTo = relativeTo || process.cwd();
+    const ref = resolveFilename(filename, relativeTo);
+    return gcl()._readConfig(ref);
+}
+exports.readRawSettings = readRawSettings;
+/**
+ *
+ * @param filenames - settings files to read
+ * @returns combined configuration
+ * @deprecated true
+ */
+function readSettingsFiles(filenames) {
+    return filenames.map((filename) => (0, readSettings_1.readSettings)(filename)).reduce((a, b) => (0, CSpellSettingsServer_1.mergeSettings)(a, b), defaultSettings);
+}
+exports.readSettingsFiles = readSettingsFiles;
+function resolveFilename(filename, relativeTo) {
+    const r = (0, resolveFile_1.resolveFile)(filename, relativeTo);
+    return {
+        filename: r.filename,
+        error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
+    };
+}
+function getGlobalSettings() {
+    return gcl().getGlobalSettings();
+}
+exports.getGlobalSettings = getGlobalSettings;
+function getCachedFileSize() {
+    return cachedFiles().size;
+}
+exports.getCachedFileSize = getCachedFileSize;
+function clearCachedSettingsFiles() {
+    return gcl().clearCachedSettingsFiles();
+}
+exports.clearCachedSettingsFiles = clearCachedSettingsFiles;
+function resolveGlobRoot(settings, pathToSettingsFile) {
+    const settingsFileDirRaw = path.dirname(pathToSettingsFile);
+    const isVSCode = path.basename(settingsFileDirRaw) === '.vscode';
+    const settingsFileDir = isVSCode ? path.dirname(settingsFileDirRaw) : settingsFileDirRaw;
+    const envGlobRoot = process.env[constants_1.ENV_CSPELL_GLOB_ROOT];
+    const defaultGlobRoot = envGlobRoot ?? '${cwd}';
+    const rawRoot = settings.globRoot ??
+        (settings.version === constants_1.configSettingsFileVersion0_1 ||
+            (envGlobRoot && !settings.version) ||
+            (isVSCode && !settings.version)
+            ? defaultGlobRoot
+            : settingsFileDir);
+    const globRoot = rawRoot.startsWith('${cwd}') ? rawRoot : path.resolve(settingsFileDir, rawRoot);
+    return globRoot;
+}
+function validationMessage(msg, fileRef) {
+    return msg + `\n  File: "${fileRef.filename}"`;
+}
+function validateRawConfigVersion(config, fileRef) {
+    const { version } = config;
+    if (version === undefined)
+        return;
+    if (typeof version !== 'string') {
+        (0, logger_1.logError)(validationMessage(`Unsupported config file version: "${version}", string expected`, fileRef));
+        return;
+    }
+    if (setOfSupportedConfigVersions.has(version))
+        return;
+    if (!/^\d+(\.\d+)*$/.test(version)) {
+        (0, logger_1.logError)(validationMessage(`Unsupported config file version: "${version}"`, fileRef));
+        return;
+    }
+    const msg = version > constants_1.currentSettingsFileVersion
+        ? `Newer config file version found: "${version}". Supported version is "${constants_1.currentSettingsFileVersion}"`
+        : `Legacy config file version found: "${version}", upgrade to "${constants_1.currentSettingsFileVersion}"`;
+    (0, logger_1.logWarning)(validationMessage(msg, fileRef));
+}
+function validateRawConfigExports(config, fileRef) {
+    if (config.default) {
+        throw new ImportError_1.ImportError(validationMessage('Module `export default` is not supported.\n  Use `module.exports =` instead.', fileRef));
+    }
+}
+function validateRawConfig(config, fileRef) {
+    const validations = [validateRawConfigExports, validateRawConfigVersion];
+    validations.forEach((fn) => fn(config, fileRef));
+}
+function createConfigLoaderInternal(cspellIO) {
+    return new ConfigLoaderInternal(cspellIO ?? (0, cspell_io_1.getDefaultCSpellIO)());
+}
+function createConfigLoader(cspellIO) {
+    return createConfigLoaderInternal(cspellIO);
+}
+exports.createConfigLoader = createConfigLoader;
+function getDefaultConfigLoaderInternal() {
+    if (defaultConfigLoader)
+        return defaultConfigLoader;
+    return (defaultConfigLoader = createConfigLoaderInternal());
+}
+function getDefaultConfigLoader() {
+    return getDefaultConfigLoaderInternal();
+}
+exports.getDefaultConfigLoader = getDefaultConfigLoader;
+const gcl = getDefaultConfigLoaderInternal;
+function cachedFiles() {
+    return gcl()._cachedFiles;
+}
+function cspellConfigExplorer() {
+    return gcl()._cspellConfigExplorer;
+}
+function cspellConfigExplorerSync() {
+    return gcl()._cspellConfigExplorerSync;
+}
+exports.__testing__ = {
+    getDefaultConfigLoaderInternal,
+    normalizeCacheSettings: normalizeRawSettings_1.normalizeCacheSettings,
+    validateRawConfigExports,
+    validateRawConfigVersion,
+};
+//# sourceMappingURL=configLoader.js.map

package/dist/Settings/Controller/configLoader/extractImportErrors.d.ts

@@ -0,0 +1,7 @@
+import { ImportFileRef } from '@cspell/cspell-types';
+import { CSpellSettingsWST } from './configLoader';
+export declare function extractImportErrors(settings: CSpellSettingsWST): ImportFileRefWithError[];
+export interface ImportFileRefWithError extends ImportFileRef {
+    error: Error;
+}
+//# sourceMappingURL=extractImportErrors.d.ts.map

package/dist/Settings/Controller/configLoader/extractImportErrors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImportErrors = void 0;
+function extractImportErrors(settings) {
+    const imports = mergeImportRefs(settings);
+    return !imports ? [] : [...imports.values()].filter(isImportFileRefWithError);
+}
+exports.extractImportErrors = extractImportErrors;
+function mergeImportRefs(left, right = {}) {
+    const imports = new Map(left.__imports || []);
+    if (left.__importRef) {
+        imports.set(left.__importRef.filename, left.__importRef);
+    }
+    if (right.__importRef) {
+        imports.set(right.__importRef.filename, right.__importRef);
+    }
+    const rightImports = right.__imports?.values() || [];
+    for (const ref of rightImports) {
+        imports.set(ref.filename, ref);
+    }
+    return imports.size ? imports : undefined;
+}
+function isImportFileRefWithError(ref) {
+    return !!ref.error;
+}
+//# sourceMappingURL=extractImportErrors.js.map

package/dist/Settings/Controller/configLoader/index.d.ts

@@ -0,0 +1,4 @@
+export { clearCachedSettingsFiles, ConfigLoader, createConfigLoader, defaultConfigFilenames, defaultFileName, getCachedFileSize, getGlobalSettings, loadConfig, loadConfigSync, loadPnP, loadPnPSync, readRawSettings, readSettingsFiles, searchForConfig, searchForConfigSync, sectionCSpell, __testing__, } from './configLoader';
+export { extractImportErrors, ImportFileRefWithError } from './extractImportErrors';
+export { readSettings } from './readSettings';
+//# sourceMappingURL=index.d.ts.map

package/dist/Settings/Controller/configLoader/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSettings = exports.extractImportErrors = exports.__testing__ = exports.sectionCSpell = exports.searchForConfigSync = exports.searchForConfig = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfigSync = exports.loadConfig = exports.getGlobalSettings = exports.getCachedFileSize = exports.defaultFileName = exports.defaultConfigFilenames = exports.createConfigLoader = exports.ConfigLoader = exports.clearCachedSettingsFiles = void 0;
+var configLoader_1 = require("./configLoader");
+Object.defineProperty(exports, "clearCachedSettingsFiles", { enumerable: true, get: function () { return configLoader_1.clearCachedSettingsFiles; } });
+Object.defineProperty(exports, "ConfigLoader", { enumerable: true, get: function () { return configLoader_1.ConfigLoader; } });
+Object.defineProperty(exports, "createConfigLoader", { enumerable: true, get: function () { return configLoader_1.createConfigLoader; } });
+Object.defineProperty(exports, "defaultConfigFilenames", { enumerable: true, get: function () { return configLoader_1.defaultConfigFilenames; } });
+Object.defineProperty(exports, "defaultFileName", { enumerable: true, get: function () { return configLoader_1.defaultFileName; } });
+Object.defineProperty(exports, "getCachedFileSize", { enumerable: true, get: function () { return configLoader_1.getCachedFileSize; } });
+Object.defineProperty(exports, "getGlobalSettings", { enumerable: true, get: function () { return configLoader_1.getGlobalSettings; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return configLoader_1.loadConfig; } });
+Object.defineProperty(exports, "loadConfigSync", { enumerable: true, get: function () { return configLoader_1.loadConfigSync; } });
+Object.defineProperty(exports, "loadPnP", { enumerable: true, get: function () { return configLoader_1.loadPnP; } });
+Object.defineProperty(exports, "loadPnPSync", { enumerable: true, get: function () { return configLoader_1.loadPnPSync; } });
+Object.defineProperty(exports, "readRawSettings", { enumerable: true, get: function () { return configLoader_1.readRawSettings; } });
+Object.defineProperty(exports, "readSettingsFiles", { enumerable: true, get: function () { return configLoader_1.readSettingsFiles; } });
+Object.defineProperty(exports, "searchForConfig", { enumerable: true, get: function () { return configLoader_1.searchForConfig; } });
+Object.defineProperty(exports, "searchForConfigSync", { enumerable: true, get: function () { return configLoader_1.searchForConfigSync; } });
+Object.defineProperty(exports, "sectionCSpell", { enumerable: true, get: function () { return configLoader_1.sectionCSpell; } });
+Object.defineProperty(exports, "__testing__", { enumerable: true, get: function () { return configLoader_1.__testing__; } });
+var extractImportErrors_1 = require("./extractImportErrors");
+Object.defineProperty(exports, "extractImportErrors", { enumerable: true, get: function () { return extractImportErrors_1.extractImportErrors; } });
+var readSettings_1 = require("./readSettings");
+Object.defineProperty(exports, "readSettings", { enumerable: true, get: function () { return readSettings_1.readSettings; } });
+//# sourceMappingURL=index.js.map

package/dist/Settings/Controller/configLoader/normalizeRawSettings.d.ts

@@ -0,0 +1,50 @@
+import { CSpellUserSettings, GlobDef, LanguageSetting } from '@cspell/cspell-types';
+import { OptionalOrUndefined } from '../../../util/types';
+interface NormalizableFields {
+    version?: string | number;
+}
+export declare function normalizeRawConfig(config: CSpellUserSettings | NormalizableFields): void;
+declare type NormalizeDictionaryDefsParams = OptionalOrUndefined<Pick<CSpellUserSettings, 'dictionaryDefinitions' | 'languageSettings'>>;
+export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDefsParams, pathToSettingsFile: string): import("../../../util/types").RemoveUndefined<{
+    dictionaryDefinitions: import("../../../Models/CSpellSettingsInternalDef").DictionaryDefinitionInternalWithSource[] | undefined;
+    languageSettings: import("../../../util/types").RemoveUndefined<{
+        dictionaryDefinitions: import("../../../Models/CSpellSettingsInternalDef").DictionaryDefinitionInternalWithSource[] | undefined;
+        languageId: string | string[];
+        locale?: string | string[];
+        local?: string | string[];
+        id?: string;
+        name?: string;
+        description?: string;
+        enabled?: boolean;
+        words?: string[];
+        flagWords?: string[];
+        ignoreWords?: string[];
+        allowCompoundWords?: boolean;
+        caseSensitive?: boolean;
+        dictionaries?: string[];
+        noSuggestDictionaries?: string[];
+        ignoreRegExpList?: import("@cspell/cspell-types").RegExpPatternList;
+        includeRegExpList?: import("@cspell/cspell-types").RegExpPatternList;
+        patterns?: import("@cspell/cspell-types").RegExpPatternDefinition[];
+        parser?: string;
+    }>[] | undefined;
+}>;
+declare type NormalizeOverrides = Pick<CSpellUserSettings, 'globRoot' | 'overrides'>;
+declare type NormalizeOverridesResult = Pick<CSpellUserSettings, 'overrides'>;
+export declare function normalizeOverrides(settings: NormalizeOverrides, pathToSettingsFile: string): NormalizeOverridesResult;
+declare type NormalizeReporters = Pick<CSpellUserSettings, 'reporters'>;
+export declare function normalizeReporters(settings: NormalizeReporters, pathToSettingsFile: string): NormalizeReporters;
+export declare function normalizeLanguageSettings(languageSettings: LanguageSetting[] | undefined): LanguageSetting[] | undefined;
+declare type NormalizeGitignoreRoot = Pick<CSpellUserSettings, 'gitignoreRoot'>;
+export declare function normalizeGitignoreRoot(settings: NormalizeGitignoreRoot, pathToSettingsFile: string): NormalizeGitignoreRoot;
+interface NormalizeSettingsGlobs {
+    globRoot?: CSpellUserSettings['globRoot'];
+    ignorePaths?: CSpellUserSettings['ignorePaths'];
+}
+interface NormalizeSettingsGlobsResult {
+    ignorePaths?: GlobDef[];
+}
+export declare function normalizeSettingsGlobs(settings: NormalizeSettingsGlobs, pathToSettingsFile: string): NormalizeSettingsGlobsResult;
+export declare function normalizeCacheSettings(settings: Pick<CSpellUserSettings, 'cache'>, pathToSettingsDir: string): Pick<CSpellUserSettings, 'cache'>;
+export {};
+//# sourceMappingURL=normalizeRawSettings.d.ts.map