cspell-lib 7.3.9 → 8.1.0

package/dist/esm/FeatureFlags/FeatureFlags.js

@@ -4,8 +4,9 @@ let systemFeatureFlags;
  * These are primarily used before a feature has been fully released.
  */
 export class FeatureFlags {
+    flags;
+    flagValues = new Map();
     constructor(flags = []) {
-        this.flagValues = new Map();
         this.flags = new Map(flags.map((f) => [f.name, f]));
     }
     register(flagOrName, description) {
@@ -43,6 +44,7 @@ export class FeatureFlags {
     }
 }
 export class UnknownFeatureFlagError extends Error {
+    flag;
     constructor(flag) {
         super(`Unknown feature flag: ${flag}`);
         this.flag = flag;

package/dist/esm/Models/TextDocument.js

@@ -4,6 +4,10 @@ import { TextDocument as VsTextDocument } from 'vscode-languageserver-textdocume
 import { getLanguagesForBasename } from '../LanguageIds.js';
 import * as Uri from '../util/Uri.js';
 class TextDocumentImpl {
+    uri;
+    languageId;
+    locale;
+    vsTextDoc;
     constructor(uri, text, languageId, locale, version) {
         this.uri = uri;
         this.languageId = languageId;

package/dist/esm/Settings/CSpellSettingsServer.d.ts

@@ -1,16 +1,15 @@
-import type { AdvancedCSpellSettingsWithSourceTrace, Glob, ImportFileRef } from '@cspell/cspell-types';
+import type { AdvancedCSpellSettingsWithSourceTrace, ImportFileRef } from '@cspell/cspell-types';
 import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef.js';
 import type { OptionalOrUndefined } from '../util/types.js';
 type CSpellSettingsWST = AdvancedCSpellSettingsWithSourceTrace;
-type CSpellSettingsWSTO = OptionalOrUndefined<AdvancedCSpellSettingsWithSourceTrace>;
-type CSpellSettingsI = CSpellSettingsInternal;
+export type CSpellSettingsWSTO = OptionalOrUndefined<AdvancedCSpellSettingsWithSourceTrace>;
+export type CSpellSettingsI = CSpellSettingsInternal;
 declare function mergeObjects(left: undefined, right: undefined): undefined;
 declare function mergeObjects<T>(left: T, right: undefined): T;
 declare function mergeObjects<T>(left: T, right: T): T;
 declare function mergeObjects<T>(left: undefined, right: T): T;
 export declare function mergeSettings(left: CSpellSettingsWSTO | CSpellSettingsI, ...settings: (CSpellSettingsWSTO | CSpellSettingsI | undefined)[]): CSpellSettingsI;
 export declare function mergeInDocSettings(left: CSpellSettingsWSTO, right: CSpellSettingsWSTO): CSpellSettingsWST;
-export declare function calcOverrideSettings(settings: CSpellSettingsWSTO, filename: string): CSpellSettingsI;
 /**
  *
  * @param settings - settings to finalize
@@ -20,14 +19,6 @@ export declare function finalizeSettings(settings: CSpellSettingsWSTO | CSpellSe
 export declare function toInternalSettings(settings: undefined): undefined;
 export declare function toInternalSettings(settings: CSpellSettingsI | CSpellSettingsWSTO): CSpellSettingsI;
 export declare function toInternalSettings(settings?: CSpellSettingsI | CSpellSettingsWSTO): CSpellSettingsI | undefined;
-/**
- * @param filename - filename
- * @param globs - globs
- * @returns true if it matches
- * @deprecated true
- * @deprecationMessage No longer actively supported. Use package: `cspell-glob`.
- */
-export declare function checkFilenameMatchesGlob(filename: string, globs: Glob | Glob[]): boolean;
 /**
  * Return a list of Setting Sources used to create this Setting.
  * @param settings the settings to search

package/dist/esm/Settings/CSpellSettingsServer.js

@@ -1,37 +1,28 @@
 import assert from 'assert';
-import { GlobMatcher } from 'cspell-glob';
-import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { onClearCache } from '../events/index.js';
 import { cleanCSpellSettingsInternal as csi, isCSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { autoResolveWeak, AutoResolveWeakCache } from '../util/AutoResolve.js';
+import { toFileUrl } from '../util/url.js';
 import * as util from '../util/util.js';
 import { configSettingsFileVersion0_1, ENV_CSPELL_GLOB_ROOT } from './constants.js';
 import { calcDictionaryDefsToLoad, mapDictDefsToInternal } from './DictionarySettings.js';
+import { mergeList, mergeListUnique } from './mergeList.js';
 import { resolvePatterns } from './patterns.js';
-function mergeListUnique(left, right) {
-    if (!Array.isArray(left))
-        return Array.isArray(right) ? right : undefined;
-    if (!Array.isArray(right))
-        return left;
-    if (!right.length)
-        return left;
-    if (!left.length)
-        return right;
-    return [...new Set([...left, ...right])];
-}
-function mergeList(left, right) {
-    if (!Array.isArray(left))
-        return Array.isArray(right) ? right : undefined;
-    if (!Array.isArray(right))
-        return left;
-    if (!left.length)
-        return right;
-    if (!right.length)
-        return left;
-    return left.concat(right);
-}
 const emptyWords = [];
 Object.freeze(emptyWords);
-const cachedMerges = new WeakMap();
+const cachedMerges = new AutoResolveWeakCache();
+const mergeCache = new AutoResolveWeakCache();
+const cacheInternalSettings = new AutoResolveWeakCache();
+const parserCache = new AutoResolveWeakCache();
+const emptyParserMap = new Map();
+onClearCache(() => {
+    parserCache.clear();
+    emptyParserMap.clear();
+    cachedMerges.clear();
+    mergeCache.clear();
+    cacheInternalSettings.clear();
+});
 function _mergeWordsCached(left, right) {
     const map = autoResolveWeak(cachedMerges, left, () => new WeakMap());
     return autoResolveWeak(map, right, () => left.concat(right));
@@ -62,11 +53,9 @@ export function mergeSettings(left, ...settings) {
     const rawSettings = settings.filter(util.isDefined).reduce(merge, toInternalSettings(left));
     return util.clean(rawSettings);
 }
-// eslint-disable-next-line @typescript-eslint/ban-types
 function isEmpty(obj) {
-    return Object.keys(obj).length === 0 && obj.constructor === Object;
+    return !obj || Object.keys(obj).length === 0;
 }
-const mergeCache = new AutoResolveWeakCache();
 function merge(left, right) {
     const map = mergeCache.get(left, () => new WeakMap());
     return autoResolveWeak(map, right, () => _merge(left, right));
@@ -176,14 +165,6 @@ function takeRightOtherwiseLeft(left, right) {
     }
     return left || right;
 }
-export function calcOverrideSettings(settings, filename) {
-    const _settings = toInternalSettings(settings);
-    const overrides = _settings.overrides || [];
-    const result = overrides
-        .filter((override) => checkFilenameMatchesGlob(filename, override.filename))
-        .reduce((settings, override) => mergeSettings(settings, override), _settings);
-    return result;
-}
 /**
  *
  * @param settings - settings to finalize
@@ -205,7 +186,6 @@ function _finalizeSettings(settings) {
     finalized.source = { name: settings.name || 'src', sources: [settings] };
     return finalized;
 }
-const cacheInternalSettings = new AutoResolveWeakCache();
 export function toInternalSettings(settings) {
     if (settings === undefined)
         return undefined;
@@ -215,24 +195,10 @@ export function toInternalSettings(settings) {
 }
 function _toInternalSettings(settings) {
     const { dictionaryDefinitions: defs, ...rest } = settings;
-    const dictionaryDefinitions = mapDictDefsToInternal(defs, filenameToDirectory(settings.source?.filename) || resolveCwd());
+    const dictionaryDefinitions = mapDictDefsToInternal(defs, (settings.source?.filename && toFileUrl(settings.source?.filename)) || resolveCwd());
     const setting = dictionaryDefinitions ? { ...rest, dictionaryDefinitions } : rest;
     return csi(setting);
 }
-function filenameToDirectory(filename) {
-    return filename ? path.dirname(filename) : undefined;
-}
-/**
- * @param filename - filename
- * @param globs - globs
- * @returns true if it matches
- * @deprecated true
- * @deprecationMessage No longer actively supported. Use package: `cspell-glob`.
- */
-export function checkFilenameMatchesGlob(filename, globs) {
-    const m = new GlobMatcher(globs);
-    return m.match(filename);
-}
 function mergeSources(left, right) {
     return {
         name: 'merged',
@@ -294,7 +260,7 @@ export function extractDependencies(settings) {
 function resolveCwd() {
     const envGlobRoot = process.env[ENV_CSPELL_GLOB_ROOT];
     const cwd = envGlobRoot || process.cwd();
-    return cwd;
+    return pathToFileURL(cwd);
 }
 function resolveParser(settings) {
     if (!settings.parser)
@@ -308,8 +274,6 @@ function resolveParser(settings) {
     assert(parser, `Parser "${parserName}" not found.`);
     return parser;
 }
-const parserCache = new AutoResolveWeakCache();
-const emptyParserMap = new Map();
 function* parsers(plugins) {
     for (const plugin of plugins) {
         if (!plugin.parsers)

package/dist/esm/Settings/Controller/ImportError.js

@@ -1,5 +1,6 @@
 import { isError } from '../../util/errors.js';
 export class ImportError extends Error {
+    cause;
     constructor(msg, cause) {
         super(msg);
         this.cause = isError(cause) ? cause : undefined;

package/dist/esm/Settings/Controller/SettingsController.js

@@ -2,6 +2,7 @@
  * The settings controller manages requests to resolve configuration settings and files.
  */
 export class SettingsController {
+    cspellIO;
     constructor(cspellIO) {
         this.cspellIO = cspellIO;
     }

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

@@ -1,164 +1,93 @@
 import type { CSpellUserSettings, ImportFileRef } from '@cspell/cspell-types';
+import type { CSpellConfigFile, CSpellConfigFileReaderWriter } from 'cspell-config-lib';
 import type { CSpellIO } from 'cspell-io';
-import type { Uri } from '../../../util/Uri.js';
-import { ImportError } from '../ImportError.js';
+import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import type { LoaderResult } from '../pnpLoader.js';
+import { ConfigSearch } from './configSearch.js';
 import { normalizeCacheSettings } from './normalizeRawSettings.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
-import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
+import type { CSpellSettingsI } from './types.js';
 export declare const sectionCSpell = "cSpell";
 export declare const defaultFileName = "cspell.json";
-export declare const defaultConfigFilenames: readonly string[];
+interface ImportedConfigEntry {
+    /** href of the configFile URL, this is the key to the cache. */
+    href: string;
+    /** The fileRef used. */
+    fileRef: ImportFileRef;
+    /** resolved config file */
+    configFile: CSpellConfigFile | undefined;
+    /** resolved settings */
+    settings: CSpellSettingsI | undefined;
+    isReady: boolean;
+    /** Resolved when the settings have been fully resolved. */
+    onReady: Promise<CSpellSettingsI>;
+    /** Resolved when the config file has been loaded. */
+    onConfigFileReady: Promise<CSpellConfigFile | Error>;
+    /** Set of all references used to catch circular references */
+    referencedSet: Set<string>;
+}
+interface CacheMergeConfigFileWithImports {
+    pnpSettings: PnPSettingsOptional | undefined;
+    referencedBy: string[] | undefined;
+    result: Promise<CSpellSettingsI>;
+}
 export declare class ConfigLoader {
     readonly cspellIO: CSpellIO;
+    onReady: Promise<void>;
     /**
      * Use `createConfigLoader`
      * @param cspellIO - CSpellIO interface for reading files.
      */
     protected constructor(cspellIO: CSpellIO);
-    protected cachedFiles: Map<string, import("../../../Models/CSpellSettingsInternalDef.js").CSpellSettingsInternal>;
-    protected cspellConfigExplorer: {
-        readonly search: (searchFrom?: string | undefined) => Promise<import("cosmiconfig/dist/types.js").CosmiconfigResult>;
-        readonly load: (filepath: string) => Promise<import("cosmiconfig/dist/types.js").CosmiconfigResult>;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
-    protected cspellConfigExplorerSync: {
-        readonly search: (searchFrom?: string | undefined) => import("cosmiconfig/dist/types.js").CosmiconfigResult;
-        readonly load: (filepath: string) => import("cosmiconfig/dist/types.js").CosmiconfigResult;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
+    private subscribeToEvents;
+    protected cachedConfig: Map<string, ImportedConfigEntry>;
+    protected cachedConfigFiles: Map<string, CSpellConfigFile>;
+    protected cachedPendingConfigFile: AutoResolveCache<string, Promise<Error | CSpellConfigFile>>;
+    protected cachedMergedConfig: WeakMap<CSpellConfigFile, CacheMergeConfigFileWithImports>;
     protected globalSettings: CSpellSettingsI | undefined;
-    /**
-     * Read / import a cspell configuration file.
-     * @param filename - the path to the file.
-     *   Supported types: json, yaml, js, and cjs. ES Modules are not supported.
-     *   - absolute path `/absolute/path/to/file`
-     *   - relative path `./path/to/file` (relative to the current working directory)
-     *   - package `@cspell/dict-typescript/cspell-ext.json`
-     */
-    readSettings(filename: string): CSpellSettingsI;
-    readSettings(filename: string, defaultValues: CSpellSettingsWST): CSpellSettingsI;
-    /**
-     * Read / import a cspell configuration file.
-     * @param filename - the path to the file.
-     *   Supported types: json, yaml, js, and cjs. ES Modules are not supported.
-     *   - absolute path `/absolute/path/to/file`
-     *   - relative path `./path/to/file` (relative to `relativeTo`)
-     *   - package `@cspell/dict-typescript/cspell-ext.json` searches for node_modules relative to `relativeTo`
-     * @param relativeTo - absolute path to start searching for relative files or node_modules.
-     */
-    readSettings(filename: string, relativeTo?: string): CSpellSettingsI;
-    readSettings(filename: string, relativeTo: string, defaultValues: CSpellSettingsWST): CSpellSettingsI;
-    readSettings(filename: string, relativeToOrDefault?: CSpellSettingsWST | string): CSpellSettingsI;
-    readSettingsAsync(filename: string, relativeTo?: string, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI>;
+    protected cspellConfigFileReaderWriter: CSpellConfigFileReaderWriter;
+    protected configSearch: ConfigSearch;
+    protected toDispose: {
+        dispose: () => void;
+    }[];
+    readSettingsAsync(filename: string | URL, relativeTo?: string | URL, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI>;
+    readConfigFile(filenameOrURL: string | URL, relativeTo?: string | URL): Promise<CSpellConfigFile | Error>;
+    searchForConfigFileLocation(searchFrom: URL | string | undefined): Promise<URL | undefined>;
+    searchForConfigFile(searchFrom: URL | string | undefined): Promise<CSpellConfigFile | undefined>;
     /**
      *
-     * @param searchFrom the directory / file to start searching from.
+     * @param searchFrom the directory / file URL to start searching from.
      * @param pnpSettings - related to Using Yarn PNP.
      * @returns the resulting settings
      */
-    searchForConfig(searchFrom: string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
-    private searchConfigLRU;
-    private _searchForConfig;
+    searchForConfig(searchFrom: URL | string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
     getGlobalSettings(): CSpellSettingsI;
+    getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     clearCachedSettingsFiles(): void;
-    /**
-     * Read a config file and inject the fileRef.
-     * @param fileRef - filename plus context, injected into the resulting config.
-     */
-    protected readConfig(fileRef: ImportFileRef): CSpellSettingsWST;
-    protected importSettings(fileRef: ImportFileRef, defaultValues: CSpellSettingsWST | undefined, pnpSettings: PnPSettingsOptional): CSpellSettingsI;
+    protected importSettings(fileRef: ImportFileRef, pnpSettings: PnPSettingsOptional | undefined, backReferences: string[]): ImportedConfigEntry;
+    private setupPnp;
+    mergeConfigFileWithImports(cfgFile: CSpellConfigFile, pnpSettings: PnPSettingsOptional | undefined, referencedBy?: string[] | undefined): Promise<CSpellSettingsI>;
+    private _mergeConfigFileWithImports;
     /**
      * 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.
      */
-    protected normalizeSettings(rawSettings: CSpellSettingsWST, pathToSettingsFile: string, pnpSettings: PnPSettingsOptional): CSpellSettingsI;
+    protected mergeImports(cfgFile: CSpellConfigFile, importedSettings: CSpellUserSettings[]): CSpellSettingsI;
+    createCSpellConfigFile(filename: URL | string, settings: CSpellUserSettings): CSpellConfigFile;
+    dispose(): void;
 }
 declare class ConfigLoaderInternal extends ConfigLoader {
     constructor(cspellIO: CSpellIO);
-    get _cachedFiles(): Map<string, import("../../../Models/CSpellSettingsInternalDef.js").CSpellSettingsInternal>;
-    get _cspellConfigExplorer(): {
-        readonly search: (searchFrom?: string | undefined) => Promise<import("cosmiconfig/dist/types.js").CosmiconfigResult>;
-        readonly load: (filepath: string) => Promise<import("cosmiconfig/dist/types.js").CosmiconfigResult>;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
-    get _cspellConfigExplorerSync(): {
-        readonly search: (searchFrom?: string | undefined) => import("cosmiconfig/dist/types.js").CosmiconfigResult;
-        readonly load: (filepath: string) => import("cosmiconfig/dist/types.js").CosmiconfigResult;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
-    readonly _readConfig: (fileRef: ImportFileRef) => import("@cspell/cspell-types").CSpellSettingsWithSourceTrace;
-    readonly _normalizeSettings: (rawSettings: import("@cspell/cspell-types").CSpellSettingsWithSourceTrace, pathToSettingsFile: string, pnpSettings: import("../../../util/types.js").OptionalOrUndefined<import("@cspell/cspell-types").PnPSettings>) => import("../../../Models/CSpellSettingsInternalDef.js").CSpellSettingsInternal;
-    normalizeSearchForConfigResultAsync(searchPath: string, searchResult: Promise<SearchForConfigResult | null>, pnpSettings: PnPSettingsOptional): Promise<NormalizeSearchForConfigResult>;
-    normalizeSearchForConfigResult(searchPath: string, searchResult: SearchForConfigResult | ImportError | undefined, pnpSettings: PnPSettingsOptional): NormalizeSearchForConfigResult;
-}
-interface SearchForConfigResult {
-    config: CSpellSettingsI | undefined;
-    filepath: string;
-    isEmpty?: boolean;
-}
-interface NormalizeSearchForConfigResult {
-    config: CSpellSettingsI;
-    filepath: string | undefined;
-    error: ImportError | undefined;
+    get _cachedFiles(): Map<string, ImportedConfigEntry>;
 }
-/**
- *
- * @param searchFrom the directory / file to start searching from.
- * @param pnpSettings - related to Using Yarn PNP.
- * @returns the resulting settings
- */
-export declare function searchForConfig(searchFrom: string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
-/**
- *
- * @param searchFrom the directory / file to start searching from.
- * @param pnpSettings - related to Using Yarn PNP.
- * @returns the resulting settings
- * @deprecated
- * @deprecationMessage Use `searchForConfig`. It is very difficult to support Sync files when settings include web requests.
- */
-export declare function searchForConfigSync(searchFrom: string | undefined, pnpSettings?: PnPSettingsOptional): CSpellSettingsI | undefined;
-/**
- * Load a CSpell configuration files.
- * @param file - path or package reference to load.
- * @param pnpSettings - PnP settings
- * @returns normalized CSpellSettings
- */
-export declare function loadConfig(file: string, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI>;
-/**
- * Load a CSpell configuration files.
- * @param filename - path or package reference to load.
- * @param pnpSettings - PnP settings
- * @returns normalized CSpellSettings
- * @deprecated
- */
-export declare function loadConfigSync(filename: string, pnpSettings?: PnPSettingsOptional): CSpellSettingsI;
-export declare function loadPnP(pnpSettings: PnPSettingsOptional, searchFrom: Uri): Promise<LoaderResult>;
-export declare function loadPnPSync(pnpSettings: PnPSettingsOptional, searchFrom: Uri): LoaderResult;
-export declare function readRawSettings(filename: string, relativeTo?: string): CSpellSettingsWST;
-export declare function getGlobalSettings(): CSpellSettingsI;
-export declare function getCachedFileSize(): number;
-export declare function clearCachedSettingsFiles(): void;
-declare function validateRawConfigVersion(config: CSpellUserSettings | {
-    version: unknown;
-}, fileRef: ImportFileRef): void;
-declare function validateRawConfigExports(config: CSpellUserSettings, fileRef: ImportFileRef): void;
+export declare function loadPnP(pnpSettings: PnPSettingsOptional, searchFrom: URL): Promise<LoaderResult>;
+declare function validateRawConfigVersion(config: CSpellConfigFile): void;
 export declare function createConfigLoader(cspellIO?: CSpellIO): ConfigLoader;
-declare function getDefaultConfigLoaderInternal(): ConfigLoaderInternal;
-export declare function getDefaultConfigLoader(): ConfigLoader;
+export declare function getDefaultConfigLoaderInternal(): ConfigLoaderInternal;
 export declare const __testing__: {
     getDefaultConfigLoaderInternal: typeof getDefaultConfigLoaderInternal;
     normalizeCacheSettings: typeof normalizeCacheSettings;
-    validateRawConfigExports: typeof validateRawConfigExports;
     validateRawConfigVersion: typeof validateRawConfigVersion;
 };
 export {};