cspell-lib 6.26.3 → 6.28.0

package/dist/Document/Document.d.ts

@@ -1,3 +1,4 @@
+import type { Uri } from '../util/Uri';
 export interface Document {
     uri: UriString;
     text?: string;
@@ -5,6 +6,7 @@ export interface Document {
     locale?: string;
 }
 export type UriString = string;
+export type UriOrString = UriString | Uri;
 export interface DocumentWithText extends Document {
     text: string;
 }

package/dist/Document/isBinaryDoc.d.ts

@@ -1,5 +1,6 @@
-import { URI } from 'vscode-uri';
+/// <reference types="node" />
+import type { Uri } from '../util/Uri';
 import type { Document } from './Document';
 export declare function isBinaryDoc(document: Document): boolean;
-export declare function isBinaryFile(filenameUri: URI, languageId?: string | string[]): boolean;
+export declare function isBinaryFile(filename: Uri | URL | string, languageId?: string | string[]): boolean;
 //# sourceMappingURL=isBinaryDoc.d.ts.map

package/dist/Document/isBinaryDoc.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBinaryFile = exports.isBinaryDoc = void 0;
-const vscode_uri_1 = require("vscode-uri");
 const LanguageIds_1 = require("../LanguageIds");
+const Uri_1 = require("../util/Uri");
 const normalizeLanguageIds_1 = require("./normalizeLanguageIds");
 function isBinaryDoc(document) {
-    return isBinaryFile(vscode_uri_1.URI.parse(document.uri), document.languageId);
+    return isBinaryFile((0, Uri_1.toUri)(document.uri), document.languageId);
 }
 exports.isBinaryDoc = isBinaryDoc;
-function isBinaryFile(filenameUri, languageId) {
+function isBinaryFile(filename, languageId) {
+    const filenameUri = (0, Uri_1.toUri)(filename);
     if (languageId) {
         const ids = (0, normalizeLanguageIds_1.normalizeLanguageIds)(languageId);
         if (ids.length)
             return (0, LanguageIds_1.isGenerated)(ids);
     }
-    const filename = vscode_uri_1.Utils.basename(filenameUri);
-    return (0, LanguageIds_1.isGeneratedFile)(filename);
+    const file = (0, Uri_1.basename)(filenameUri);
+    return (0, LanguageIds_1.isGeneratedFile)(file);
 }
 exports.isBinaryFile = isBinaryFile;
 //# sourceMappingURL=isBinaryDoc.js.map

package/dist/Document/resolveDocument.js

@@ -1,14 +1,37 @@
 "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.resolveDocument = exports.resolveDocumentToTextDocument = exports.documentToTextDocument = exports.fileToTextDocument = exports.fileToDocument = void 0;
 const promises_1 = require("fs/promises");
-const vscode_uri_1 = require("vscode-uri");
 const TextDocument_1 = require("../Models/TextDocument");
+const Uri = __importStar(require("../util/Uri"));
 const util_1 = require("../util/util");
 const defaultEncoding = 'utf8';
 function fileToDocument(file, text, languageId, locale) {
     return (0, util_1.clean)({
-        uri: vscode_uri_1.URI.file(file).toString(),
+        uri: Uri.toUri(file).toString(),
         text,
         languageId,
         locale,
@@ -30,7 +53,7 @@ async function resolveDocumentToTextDocument(doc) {
 exports.resolveDocumentToTextDocument = resolveDocumentToTextDocument;
 async function readDocument(filename, encoding = defaultEncoding) {
     const text = await (0, promises_1.readFile)(filename, encoding);
-    const uri = vscode_uri_1.URI.file(filename).toString();
+    const uri = Uri.toUri(filename).toString();
     return {
         uri,
         text,
@@ -39,11 +62,11 @@ async function readDocument(filename, encoding = defaultEncoding) {
 function resolveDocument(document, encoding) {
     if (isDocumentWithText(document))
         return Promise.resolve(document);
-    const uri = vscode_uri_1.URI.parse(document.uri);
+    const uri = Uri.toUri(document.uri);
     if (uri.scheme !== 'file') {
         throw new Error(`Unsupported schema: "${uri.scheme}", open "${uri.toString()}"`);
     }
-    return readDocument(uri.fsPath, encoding);
+    return readDocument(Uri.uriToFilePath(uri), encoding);
 }
 exports.resolveDocument = resolveDocument;
 function isDocumentWithText(doc) {

package/dist/LanguageIds.js

@@ -234,10 +234,11 @@ exports.languageExtensionDefinitions = [
     { id: 'spv', extensions: ['.spv'], format: 'Binary', description: 'SPSS Output Document' },
     { id: 'mdb', extensions: ['.mdb'], format: 'Binary', description: 'Microsoft Access DB' },
     { id: 'webm', extensions: ['.webm'], format: 'Binary', description: 'WebM is an audiovisual media file format.' },
+    { id: 'trie', extensions: ['.trie'], format: 'Binary', description: 'CSpell dictionary file.' },
 ];
 const binaryFormatIds = exports.languageExtensionDefinitions.filter((d) => d.format === 'Binary').map((d) => d.id);
 exports.binaryLanguages = new Set(['binary', 'image', 'video', 'fonts'].concat(binaryFormatIds));
-exports.generatedFiles = new Set([...exports.binaryLanguages, 'map', 'lock', 'pdf', 'cache_files', 'rsa', 'pem']);
+exports.generatedFiles = new Set([...exports.binaryLanguages, 'map', 'lock', 'pdf', 'cache_files', 'rsa', 'pem', 'trie']);
 exports.languageIds = exports.languageExtensionDefinitions.map(({ id }) => id);
 const mapExtensionToSetOfLanguageIds = buildLanguageExtensionMapSet(exports.languageExtensionDefinitions);
 const mapExtensionToLanguageIds = buildExtensionToLanguageIdMap(mapExtensionToSetOfLanguageIds);

package/dist/Models/TextDocument.d.ts

@@ -1,4 +1,4 @@
-import * as Uri from './Uri';
+import * as Uri from '../util/Uri';
 export type DocumentUri = Uri.Uri;
 export interface Position {
     line: number;
@@ -13,6 +13,26 @@ export interface TextDocumentLine {
     readonly offset: number;
     readonly position: Position;
 }
+export interface TextDocumentRef {
+    /**
+     * The associated URI for this document. Most documents have the __file__-scheme, indicating that they
+     * represent files on disk. However, some documents may have other schemes indicating that they are not
+     * available on disk.
+     */
+    readonly uri: DocumentUri;
+    /**
+     * The identifier of the language associated with this document.
+     */
+    readonly languageId?: string | string[] | undefined;
+    /**
+     * the raw Document Text
+     */
+    readonly text?: string | undefined;
+    /**
+     * The natural language locale.
+     */
+    readonly locale?: string | undefined;
+}
 /**
  * A simple text document. Not to be implemented. The document keeps the content
  * as string.

package/dist/Models/TextDocument.js

@@ -31,7 +31,7 @@ const assert_1 = __importDefault(require("assert"));
 const fs_1 = require("fs");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const LanguageIds_1 = require("../LanguageIds");
-const Uri = __importStar(require("./Uri"));
+const Uri = __importStar(require("../util/Uri"));
 class TextDocumentImpl {
     constructor(uri, text, languageId, locale, version) {
         this.uri = uri;
@@ -130,7 +130,7 @@ function isTextDocumentImpl(doc) {
 }
 async function loadTextDocument(filename, languageId) {
     const uri = Uri.toUri(filename);
-    const content = await fs_1.promises.readFile(uri.fsPath, 'utf8');
+    const content = await fs_1.promises.readFile(Uri.uriToFilePath(uri), 'utf8');
     return createTextDocument({ uri, languageId, content });
 }
 exports.loadTextDocument = loadTextDocument;

package/dist/Settings/CSpellSettingsServer.js

@@ -102,7 +102,12 @@ exports.mergeSettings = mergeSettings;
 function isEmpty(obj) {
     return Object.keys(obj).length === 0 && obj.constructor === Object;
 }
+const mergeCache = new AutoResolve_1.AutoResolveWeakCache();
 function merge(left, right) {
+    const map = mergeCache.get(left, () => new WeakMap());
+    return (0, AutoResolve_1.autoResolveWeak)(map, right, () => _merge(left, right));
+}
+function _merge(left, right) {
     const _left = toInternalSettings(left);
     const _right = toInternalSettings(right);
     if (left === right) {
@@ -123,13 +128,20 @@ function merge(left, right) {
     const includeRegExpList = takeRightOtherwiseLeft(_left.includeRegExpList, _right.includeRegExpList);
     const optionals = includeRegExpList?.length ? { includeRegExpList } : {};
     const version = max(_left.version, _right.version);
+    const valuesToClear = {
+        name: undefined,
+        id: undefined,
+        description: undefined,
+        globRoot: undefined,
+        import: undefined,
+        __importRef: undefined,
+    };
     const settings = (0, CSpellSettingsInternalDef_1.cleanCSpellSettingsInternal)({
         ..._left,
         ..._right,
         ...optionals,
+        ...valuesToClear,
         version,
-        id: undefined,
-        name: undefined,
         words: mergeWordsCached(_left.words, _right.words),
         userWords: mergeWordsCached(_left.userWords, _right.userWords),
         flagWords: mergeWordsCached(_left.flagWords, _right.flagWords),
@@ -149,12 +161,8 @@ function merge(left, right) {
         overrides: versionBasedMergeList(_left.overrides, _right.overrides, version),
         features: mergeObjects(_left.features, _right.features),
         source: mergeSources(_left, _right),
-        description: undefined,
-        globRoot: undefined,
-        import: undefined,
         plugins: mergeList(_left.plugins, _right.plugins),
         __imports: mergeImportRefs(_left, _right),
-        __importRef: undefined,
     });
     return settings;
 }
@@ -236,17 +244,21 @@ function _finalizeSettings(settings) {
     finalized.source = { name: settings.name || 'src', sources: [settings] };
     return finalized;
 }
+const cacheInternalSettings = new AutoResolve_1.AutoResolveWeakCache();
 function toInternalSettings(settings) {
     if (settings === undefined)
         return undefined;
     if ((0, CSpellSettingsInternalDef_1.isCSpellSettingsInternal)(settings))
         return settings;
+    return cacheInternalSettings.get(settings, _toInternalSettings);
+}
+exports.toInternalSettings = toInternalSettings;
+function _toInternalSettings(settings) {
     const { dictionaryDefinitions: defs, ...rest } = settings;
     const dictionaryDefinitions = (0, DictionarySettings_1.mapDictDefsToInternal)(defs, filenameToDirectory(settings.source?.filename) || resolveCwd());
     const setting = dictionaryDefinitions ? { ...rest, dictionaryDefinitions } : rest;
     return (0, CSpellSettingsInternalDef_1.cleanCSpellSettingsInternal)(setting);
 }
-exports.toInternalSettings = toInternalSettings;
 function filenameToDirectory(filename) {
     return filename ? path.dirname(filename) : undefined;
 }

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

@@ -0,0 +1,12 @@
+import type { CSpellSettings, PnPSettings } from '@cspell/cspell-types';
+import type { OptionalOrUndefined } from '../../../util/types';
+export type PnPSettingsOptional = OptionalOrUndefined<PnPSettings>;
+export declare const defaultPnPSettings: PnPSettings;
+/**
+ * create PnPSettings object that can be used to compare to the last call.
+ * This is to reduce object churn and unnecessary configuration loading.
+ * @param settings - value to normalize
+ * @returns
+ */
+export declare function normalizePnPSettings(settings: PnPSettingsOptional | CSpellSettings): PnPSettings;
+//# sourceMappingURL=PnPSettings.d.ts.map

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePnPSettings = exports.defaultPnPSettings = void 0;
+const util_1 = require("../../../util/util");
+exports.defaultPnPSettings = Object.freeze({});
+let lastPnP = exports.defaultPnPSettings;
+/**
+ * create PnPSettings object that can be used to compare to the last call.
+ * This is to reduce object churn and unnecessary configuration loading.
+ * @param settings - value to normalize
+ * @returns
+ */
+function normalizePnPSettings(settings) {
+    if (equal(lastPnP, settings))
+        return lastPnP;
+    if (equal(exports.defaultPnPSettings, settings))
+        return exports.defaultPnPSettings;
+    const { usePnP, pnpFiles } = settings;
+    return (lastPnP = (0, util_1.clean)({ usePnP, pnpFiles }));
+}
+exports.normalizePnPSettings = normalizePnPSettings;
+function equal(a, b) {
+    return (a === b ||
+        (a.usePnP === b.usePnP && (a.pnpFiles === b.pnpFiles || a.pnpFiles?.join('|') === b.pnpFiles?.join('|'))));
+}
+//# sourceMappingURL=PnPSettings.js.map

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

@@ -1,11 +1,11 @@
-import type { CSpellUserSettings, ImportFileRef, PnPSettings as PnPSettingsStrict } from '@cspell/cspell-types';
+import type { CSpellUserSettings, ImportFileRef } from '@cspell/cspell-types';
 import type { CSpellIO } from 'cspell-io';
-import { URI } from 'vscode-uri';
-import type { OptionalOrUndefined } from '../../../util/types';
+import type { Uri } from '../../../util/Uri';
+import { ImportError } from '../ImportError';
 import type { LoaderResult } from '../pnpLoader';
 import { normalizeCacheSettings } from './normalizeRawSettings';
+import type { PnPSettingsOptional } from './PnPSettings';
 import type { CSpellSettingsI, CSpellSettingsWST } from './types';
-type PnPSettings = OptionalOrUndefined<PnPSettingsStrict>;
 export declare const sectionCSpell = "cSpell";
 export declare const defaultFileName = "cspell.json";
 export declare const defaultConfigFilenames: readonly string[];
@@ -17,20 +17,8 @@ export declare class ConfigLoader {
      */
     protected constructor(cspellIO: CSpellIO);
     protected cachedFiles: Map<string, import("../../../Models/CSpellSettingsInternalDef").CSpellSettingsInternal>;
-    protected cspellConfigExplorer: {
-        readonly search: (searchFrom?: string | undefined) => Promise<import("cosmiconfig/dist/types").CosmiconfigResult>;
-        readonly load: (filepath: string) => Promise<import("cosmiconfig/dist/types").CosmiconfigResult>;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
-    protected cspellConfigExplorerSync: {
-        readonly search: (searchFrom?: string | undefined) => import("cosmiconfig/dist/types").CosmiconfigResult;
-        readonly load: (filepath: string) => import("cosmiconfig/dist/types").CosmiconfigResult;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
+    protected cspellConfigExplorer: import("cosmiconfig").PublicExplorer;
+    protected cspellConfigExplorerSync: import("cosmiconfig").PublicExplorerSync;
     protected globalSettings: CSpellSettingsI | undefined;
     /**
      * Read / import a cspell configuration file.
@@ -54,6 +42,16 @@ export declare class ConfigLoader {
     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>;
+    /**
+     *
+     * @param searchFrom the directory / file 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;
     getGlobalSettings(): CSpellSettingsI;
     clearCachedSettingsFiles(): void;
     /**
@@ -61,33 +59,33 @@ export declare class ConfigLoader {
      * @param fileRef - filename plus context, injected into the resulting config.
      */
     protected readConfig(fileRef: ImportFileRef): CSpellSettingsWST;
-    protected importSettings(fileRef: ImportFileRef, defaultValues: CSpellSettingsWST | undefined, pnpSettings: PnPSettings): CSpellSettingsI;
+    protected importSettings(fileRef: ImportFileRef, defaultValues: CSpellSettingsWST | undefined, pnpSettings: PnPSettingsOptional): CSpellSettingsI;
     /**
      * 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: PnPSettings): CSpellSettingsI;
+    protected normalizeSettings(rawSettings: CSpellSettingsWST, pathToSettingsFile: string, pnpSettings: PnPSettingsOptional): CSpellSettingsI;
 }
 declare class ConfigLoaderInternal extends ConfigLoader {
     constructor(cspellIO: CSpellIO);
     get _cachedFiles(): Map<string, import("../../../Models/CSpellSettingsInternalDef").CSpellSettingsInternal>;
-    get _cspellConfigExplorer(): {
-        readonly search: (searchFrom?: string | undefined) => Promise<import("cosmiconfig/dist/types").CosmiconfigResult>;
-        readonly load: (filepath: string) => Promise<import("cosmiconfig/dist/types").CosmiconfigResult>;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
-    get _cspellConfigExplorerSync(): {
-        readonly search: (searchFrom?: string | undefined) => import("cosmiconfig/dist/types").CosmiconfigResult;
-        readonly load: (filepath: string) => import("cosmiconfig/dist/types").CosmiconfigResult;
-        readonly clearLoadCache: () => void;
-        readonly clearSearchCache: () => void;
-        readonly clearCaches: () => void;
-    };
+    get _cspellConfigExplorer(): import("cosmiconfig").PublicExplorer;
+    get _cspellConfigExplorerSync(): import("cosmiconfig").PublicExplorerSync;
     readonly _readConfig: (fileRef: ImportFileRef) => import("@cspell/cspell-types").CSpellSettingsWithSourceTrace;
-    readonly _normalizeSettings: (rawSettings: import("@cspell/cspell-types").CSpellSettingsWithSourceTrace, pathToSettingsFile: string, pnpSettings: OptionalOrUndefined<PnPSettingsStrict>) => import("../../../Models/CSpellSettingsInternalDef").CSpellSettingsInternal;
+    readonly _normalizeSettings: (rawSettings: import("@cspell/cspell-types").CSpellSettingsWithSourceTrace, pathToSettingsFile: string, pnpSettings: import("../../../util/types").OptionalOrUndefined<import("@cspell/cspell-types").PnPSettings>) => import("../../../Models/CSpellSettingsInternalDef").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;
 }
 /**
  *
@@ -95,7 +93,7 @@ declare class ConfigLoaderInternal extends ConfigLoader {
  * @param pnpSettings - related to Using Yarn PNP.
  * @returns the resulting settings
  */
-export declare function searchForConfig(searchFrom: string | undefined, pnpSettings?: PnPSettings): Promise<CSpellSettingsI | undefined>;
+export declare function searchForConfig(searchFrom: string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
 /**
  *
  * @param searchFrom the directory / file to start searching from.
@@ -104,23 +102,24 @@ export declare function searchForConfig(searchFrom: string | undefined, pnpSetti
  * @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?: PnPSettings): CSpellSettingsI | undefined;
+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?: PnPSettings): Promise<CSpellSettingsI>;
+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?: PnPSettings): CSpellSettingsI;
-export declare function loadPnP(pnpSettings: PnPSettings, searchFrom: URI): Promise<LoaderResult>;
-export declare function loadPnPSync(pnpSettings: PnPSettings, searchFrom: URI): LoaderResult;
+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;