cspell-lib 9.6.4 → 9.8.0

package/dist/lib/Models/ValidationIssue.d.ts

@@ -1,7 +1,14 @@
 import type { ExtendedSuggestion } from './Suggestion.js';
-import type { ValidationResult } from './ValidationResult.js';
+import type { ValidationResult, ValidationResultRPC } from './ValidationResult.js';
 export interface ValidationIssue extends ValidationResult {
     suggestions?: string[] | undefined;
     suggestionsEx?: ExtendedSuggestion[] | undefined;
 }
+/**
+ * The ValidationIssueRPC is used for RPC communication. It is a subset of ValidationIssue that can be serialized.
+ */
+export interface ValidationIssueRPC extends ValidationResultRPC {
+    suggestionsEx?: ExtendedSuggestion[] | undefined;
+}
+export declare function toValidationIssueRPC(issue: ValidationIssue, index?: number): ValidationIssueRPC;
 //# sourceMappingURL=ValidationIssue.d.ts.map

package/dist/lib/Models/ValidationIssue.js

@@ -1,2 +1,16 @@
-export {};
+export function toValidationIssueRPC(issue) {
+    const { text, length, offset, message, issueType, hasPreferredSuggestions, hasSimpleSuggestions, isFlagged, isFound, suggestionsEx, } = issue;
+    return {
+        text,
+        offset,
+        length,
+        message,
+        issueType,
+        hasPreferredSuggestions,
+        hasSimpleSuggestions,
+        isFlagged,
+        isFound,
+        suggestionsEx,
+    };
+}
 //# sourceMappingURL=ValidationIssue.js.map

package/dist/lib/Models/ValidationResult.d.ts

@@ -1,7 +1,28 @@
-import type { Issue, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
-export interface ValidationResult extends TextOffsetRW, Pick<Issue, 'message' | 'issueType' | 'hasPreferredSuggestions' | 'hasSimpleSuggestions'> {
-    line: TextOffsetRW;
+import type { Issue, TextOffset as TextOffset } from '@cspell/cspell-types';
+export interface ValidationResult extends Omit<TextOffset, 'length'>, Pick<Issue, 'message' | 'issueType' | 'hasPreferredSuggestions' | 'hasSimpleSuggestions'> {
+    length?: number | undefined;
+    line: TextOffset;
     isFlagged?: boolean | undefined;
     isFound?: boolean | undefined;
 }
+/**
+ * The ValidationResultRPC is used for RPC communication. It is a subset of ValidationResult that can be serialized.
+ *
+ * The URI, document, row, and column information are not included in the RPC version of ValidationResult
+ * because they can be calculated from the offset and the document text.
+ */
+export interface ValidationResultRPC extends Pick<ValidationResult, 'text' | 'length' | 'offset' | 'message' | 'issueType' | 'hasPreferredSuggestions' | 'hasSimpleSuggestions' | 'isFlagged' | 'isFound'> {
+    /**
+     * The line information is not included in the RPC version of ValidationResult because it can be calculated from the offset and the document text.
+     */
+    line?: undefined;
+    /**
+     * The context information is not included in the RPC version of ValidationResult because it can be calculated from the offset and the document text.
+     */
+    context?: undefined;
+    uri?: undefined;
+    doc?: undefined;
+    row?: undefined;
+    col?: undefined;
+}
 //# sourceMappingURL=ValidationResult.d.ts.map

package/dist/lib/Settings/CSpellSettingsServer.js

@@ -4,8 +4,7 @@ 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 './internal/index.js';
-import { cleanCSpellSettingsInternal as csi, isCSpellSettingsInternal } from './internal/index.js';
+import { calcDictionaryDefsToLoad, cleanCSpellSettingsInternal as csi, isCSpellSettingsInternal, mapDictDefsToInternal, } from './internal/index.js';
 import { mergeList, mergeListUnique } from './mergeList.js';
 import { resolvePatterns } from './patterns.js';
 import { CwdUrlResolver } from './resolveCwd.js';
@@ -129,6 +128,7 @@ function _merge(left, right) {
         features: mergeObjects(_left.features, _right.features),
         source: mergeSources(_left, _right),
         plugins: mergeList(_left.plugins, _right.plugins),
+        vfs: mergeObjects(_left.vfs, _right.vfs),
         __imports: mergeImportRefs(_left, _right),
     });
     return settings;

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

@@ -7,10 +7,10 @@ import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import { FileResolver } from '../../../util/resolveFile.js';
 import type { LoaderResult } from '../pnpLoader.js';
 import { ConfigSearch } from './configSearch.js';
-import type { StopSearchAt } from './defaultConfigLoader.js';
 import { normalizeCacheSettings } from './normalizeRawSettings.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
 import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
+export type StopSearchAt = URL | string | (URL | string)[] | undefined;
 export declare const sectionCSpell = "cSpell";
 export declare const defaultFileName = "cspell.json";
 interface ImportedConfigEntry {
@@ -103,7 +103,6 @@ export declare class ConfigLoader implements IConfigLoader {
     readonly templateVariables: Record<string, string>;
     onReady: Promise<void>;
     readonly fileResolver: FileResolver;
-    private _isTrusted;
     /**
      * Use `createConfigLoader`
      * @param virtualFs - virtual file system to use.
@@ -155,6 +154,7 @@ export declare class ConfigLoader implements IConfigLoader {
      * @param pathToSettingsFile - path to the source file of the configuration settings.
      */
     protected mergeImports(cfgFile: CSpellConfigFile, importedSettings: CSpellUserSettings[]): Promise<CSpellSettingsI>;
+    registerVirtualFiles(settings: CSpellSettings): Promise<void>;
     createCSpellConfigFile(filename: URL | string, settings: CSpellUserSettings): CSpellConfigFile;
     toCSpellConfigFile(cfg: ICSpellConfigFile): CSpellConfigFile;
     dispose(): void;

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

@@ -1,9 +1,8 @@
 import assert from 'node:assert';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { CSpellConfigFile, CSpellConfigFileWithErrors } from 'cspell-config-lib';
-import { createReaderWriter } from 'cspell-config-lib';
-import { isUrlLike, toFileURL } from 'cspell-io';
+import { createReaderWriter, CSpellConfigFile, CSpellConfigFileWithErrors } from 'cspell-config-lib';
+import { CSPELL_VFS_PROTOCOL, isUrlLike, toFileURL } from 'cspell-io';
 import { URI, Utils as UriUtils } from 'vscode-uri';
 import { onClearCache } from '../../../events/index.js';
 import { getVirtualFS } from '../../../fileSystem.js';
@@ -43,7 +42,9 @@ export class ConfigLoader {
     templateVariables;
     onReady;
     fileResolver;
-    _isTrusted = true;
+    #isTrusted = true;
+    /** the href of known dictionary files that have been added to the cspell-vfs:// */
+    #knownVirtualFiles = new Set();
     /**
      * Use `createConfigLoader`
      * @param virtualFs - virtual file system to use.
@@ -154,6 +155,7 @@ export class ConfigLoader {
         this.cachedMergedConfig = new WeakMap();
         this.cachedCSpellConfigFileInMemory = new WeakMap();
         this.prefetchGlobalSettingsAsync();
+        this.#knownVirtualFiles.clear();
     }
     /**
      * Resolve and merge the settings from the imports.
@@ -292,6 +294,7 @@ export class ConfigLoader {
         });
         const importSettings = await Promise.all(pendingImports);
         const cfg = await this.mergeImports(cfgFile, importSettings);
+        await this.registerVirtualFiles(cfg);
         return cfg;
     }
     /**
@@ -340,6 +343,24 @@ export class ConfigLoader {
         }
         return finalizeSettings;
     }
+    registerVirtualFiles(settings) {
+        if (!settings.vfs)
+            return Promise.resolve();
+        const entries = Object.entries(settings.vfs);
+        const waitFor = [];
+        for (const [href, entry] of entries) {
+            if (this.#knownVirtualFiles.has(href))
+                continue;
+            assert(href.startsWith(CSPELL_VFS_PROTOCOL + '///'), `Invalid virtual file URL: ${href}`);
+            const url = toFileURL(href);
+            let content = entry.data;
+            if (typeof content === 'string' && entry.encoding === 'base64') {
+                content = Buffer.from(content, 'base64');
+            }
+            waitFor.push(this.fs.writeFile({ url, content }).then(() => this.#knownVirtualFiles.add(href)));
+        }
+        return Promise.all(waitFor).then(() => undefined);
+    }
     createCSpellConfigFile(filename, settings) {
         const map = autoResolveWeak(this.cachedCSpellConfigFileInMemory, settings, () => new Map());
         return autoResolve(map, filename, () => this.cspellConfigFileReaderWriter.toCSpellConfigFile({ url: toFileURL(filename), settings }));
@@ -381,10 +402,10 @@ export class ConfigLoader {
         };
     }
     get isTrusted() {
-        return this._isTrusted;
+        return this.#isTrusted;
     }
     setIsTrusted(isTrusted) {
-        this._isTrusted = isTrusted;
+        this.#isTrusted = isTrusted;
         this.clearCachedSettingsFiles();
         this.configSearch = new ConfigSearch(searchPlaces, isTrusted ? trustedSearch : unTrustedSearch, this.fs);
         this.cspellConfigFileReaderWriter.setUntrustedExtensions(isTrusted ? [] : defaultJsExtensions);

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

@@ -4,7 +4,6 @@ import type { IConfigLoader, SearchForConfigOptions } from './configLoader.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
 import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
 export type { CSpellConfigFile, ICSpellConfigFile } from 'cspell-config-lib';
-export type StopSearchAt = URL | string | (URL | string)[] | undefined;
 /**
  *
  * @param searchFrom the directory / file to start searching from.

package/dist/lib/Settings/DefaultSettings.d.ts

@@ -1,4 +1,15 @@
 import type { CSpellSettingsInternal } from './internal/index.js';
+export declare const STATIC_DEFAULTS: {
+    readonly id: "static_defaults";
+    readonly language: "en";
+    readonly name: "Static Defaults";
+    readonly enabled: true;
+    readonly maxNumberOfProblems: 100;
+    readonly numSuggestions: 10;
+    readonly suggestionsTimeout: 500;
+    readonly suggestionNumChanges: 3;
+    readonly allowCompoundWords: false;
+};
 export declare const _defaultSettingsBasis: Readonly<CSpellSettingsInternal>;
 export declare const _defaultSettings: Readonly<CSpellSettingsInternal>;
 declare class DefaultSettingsLoader {

package/dist/lib/Settings/DefaultSettings.js

@@ -69,20 +69,31 @@ const definedDefaultRegExpExcludeList = [
 ];
 // This bit of copying is done to have the compiler ensure that the defaults exist.
 const defaultRegExpExcludeList = definedDefaultRegExpExcludeList;
-export const _defaultSettingsBasis = Object.freeze(createCSpellSettingsInternal({
+export const STATIC_DEFAULTS = {
     id: 'static_defaults',
     language: 'en',
     name: 'Static Defaults',
     enabled: true,
-    enabledLanguageIds: [],
     maxNumberOfProblems: 100,
     numSuggestions: 10,
     suggestionsTimeout: 500,
     suggestionNumChanges: 3,
+    allowCompoundWords: false,
+};
+export const _defaultSettingsBasis = Object.freeze(createCSpellSettingsInternal({
+    id: STATIC_DEFAULTS.id,
+    language: STATIC_DEFAULTS.language,
+    name: STATIC_DEFAULTS.name,
+    enabled: STATIC_DEFAULTS.enabled,
+    enabledLanguageIds: [],
+    maxNumberOfProblems: STATIC_DEFAULTS.maxNumberOfProblems,
+    numSuggestions: STATIC_DEFAULTS.numSuggestions,
+    suggestionsTimeout: STATIC_DEFAULTS.suggestionsTimeout,
+    suggestionNumChanges: STATIC_DEFAULTS.suggestionNumChanges,
     words: [],
     userWords: [],
     ignorePaths: [],
-    allowCompoundWords: false,
+    allowCompoundWords: STATIC_DEFAULTS.allowCompoundWords,
     patterns: defaultRegExpPatterns,
     ignoreRegExpList: [],
     languageSettings: [],

package/dist/lib/Settings/constants.js

@@ -3,4 +3,5 @@ export const configSettingsFileVersion0_2 = '0.2';
 export const currentSettingsFileVersion = configSettingsFileVersion0_2;
 export const ENV_CSPELL_GLOB_ROOT = 'CSPELL_GLOB_ROOT';
 export const defaultConfigFileModuleRef = '@cspell/cspell-bundled-dicts/cspell-default.json';
+// export const defaultConfigFileModuleRef = '@cspell/cspell-bundled-dicts/cspell-bundled.js';
 //# sourceMappingURL=constants.js.map

package/dist/lib/Settings/sanitizeSettings.js

@@ -61,6 +61,8 @@ const handlers = {
     reporters: skip,
     showStatus: copy1,
     spellCheckDelayMs: copy1,
+    substitutionDefinitions: copy1,
+    substitutions: copy1,
     suggestionNumChanges: copy1,
     suggestionsTimeout: copy1,
     suggestWords: copy1,
@@ -177,6 +179,8 @@ const LanguageSettingsHandlers = {
     name: skip,
     noSuggestDictionaries: copy1,
     patterns: copyPatternsField,
+    substitutionDefinitions: copy1,
+    substitutions: copy1,
     suggestWords: copy1,
     unknownWords: copy1,
     words: copy1,
@@ -235,6 +239,8 @@ const OverridesHandlers = {
     numSuggestions: copy1,
     patterns: copyPatternsField,
     pnpFiles: skip,
+    substitutionDefinitions: copy1,
+    substitutions: copy1,
     suggestionNumChanges: copy1,
     suggestionsTimeout: copy1,
     suggestWords: copy1,

package/dist/lib/Transform/SourceMap.d.ts

@@ -0,0 +1,115 @@
+import type { Range, SourceMap } from '@cspell/cspell-types';
+export interface SourceMapCursor {
+    /**
+     * The source map being traversed.
+     */
+    readonly sourceMap: SourceMap;
+    /**
+     * The current index in the source map.
+     */
+    readonly idx: number;
+    /**
+     * The base offset in the source text.
+     */
+    readonly begin0: number;
+    /**
+     * The base offset in the transformed text.
+     */
+    readonly begin1: number;
+    reset(): void;
+    mapOffsetToDest(offsetInSrc: number): number;
+    mapOffsetToSrc(offsetInDst: number): number;
+    mapRangeToSrc(rangeInDst: Range): Range;
+}
+declare class SourceMapCursorImpl implements SourceMapCursor {
+    sourceMap: SourceMap;
+    idx: number;
+    begin0: number;
+    begin1: number;
+    /**
+     * The delta in the source
+     */
+    d0: number;
+    /**
+     * The delta in the transformed text.
+     */
+    d1: number;
+    /**
+     * Indicates whether the current segment is linear (1:1) or non-linear.
+     * A linear segment has equal deltas in the source and transformed text,
+     * while a non-linear segment has different deltas.
+     * It is possible that a non-linear segment has the same deltas,
+     * but it is not possible for a linear segment to have different deltas.
+     */
+    linear: boolean;
+    /**
+     * indicates that the cursor has reached the end of the source map.
+     */
+    done: boolean;
+    constructor(sourceMap: SourceMap);
+    next(): boolean;
+    mapOffsetToDest(offsetInSrc: number): number;
+    mapOffsetToSrc(offsetInDst: number): number;
+    mapRangeToSrc(rangeInDst: Range): Range;
+    reset(): void;
+}
+/**
+ * Create a cursor for traversing a source map.
+ * @param sourceMap - The source map to create the cursor for. The map must be pairs of values (even, odd).
+ * @returns A cursor initialized to the start of the source map. The cursor can be used to traverse the source map and
+ *   calculate offsets in the transformed text based on offsets in the source text.
+ */
+export declare function createSourceMapCursor(sourceMap: SourceMap): SourceMapCursorImpl;
+export declare function createSourceMapCursor(sourceMap: SourceMap | undefined): SourceMapCursorImpl | undefined;
+/**
+ * Calculated the transformed offset in the destination text based on the source map and the offset in the source text.
+ * @param cursor - The cursor to use for the mapping. If undefined or empty, the input offset is returned, assuming it is a 1:1 mapping.
+ * @param offsetInSrc - the offset in the source text to map to the transformed text. The offset is relative to the start of the text range.
+ * @returns The offset in the transformed text corresponding to the input offset in the source text. The offset is relative to the start of the text range.
+ */
+export declare function calcOffsetInDst(cursor: SourceMapCursor | undefined, offsetInSrc: number): number;
+/**
+ * Calculated the transformed offset in the source text based on the source map and the offset in the transformed text.
+ * @param cursor - The cursor to use for the mapping. If undefined or empty, the input offset is returned, assuming it is a 1:1 mapping.
+ * @param offsetInDst - the offset in the transformed text to map to the source text. The offset is relative to the start of the text range.
+ * @returns The offset in the source text corresponding to the input offset in the transformed text. The offset is relative to the start of the text range.
+ */
+export declare function calcOffsetInSrc(cursor: SourceMapCursor | undefined, offsetInDst: number): number;
+/**
+ * Map offset pairs to a source map. The input map is expected to be pairs of absolute offsets in the source and transformed text.
+ * The output map is pairs of lengths.
+ * @param map - The input map to convert. The map must be pairs of values (even, odd) where the even values are offsets in the source
+ *   text and the odd values are offsets in the transformed text. The offsets are absolute offsets from the start of the text range.
+ * @returns a SourceMap
+ */
+export declare function mapOffsetPairsToSourceMap(map: number[] | undefined): SourceMap | undefined;
+/**
+ * Merge two source maps into a single source map. The first map transforms from the
+ * original text to an intermediate text, and the second map transforms from the intermediate
+ * text to the final text. The resulting map represents the transformation directly from the
+ * original text to the final text.
+ *
+ * Concept:
+ * [markdown codeblock] -> <first map> -> [JavaScript code] -> <second map> -> [string value]
+ *
+ * Some kinds of transforms:
+ * - markdown code block extraction
+ * - unicode normalization
+ * - html entity substitution
+ * - url decoding
+ * - etc.
+ *
+ * The result of each transform is a {@link SourceMap}. When multiple transforms are applied,
+ * the source maps can be merged to create a single map that represents the cumulative effect
+ * of all transforms. This is useful for accurately mapping positions in the final transformed
+ * text back to their corresponding positions in the original text, which is essential for
+ * reporting spelling issues in the correct context.
+ *
+ * @param first - The first transformation map from the original text to the intermediate.
+ * @param second - The second transformation map from the intermediate, to the final text.
+ */
+export declare function mergeSourceMaps(first: SourceMap | undefined, second: SourceMap | undefined): SourceMap | undefined;
+export declare function sliceSourceMapToSourceRange(map: SourceMap | undefined, range: Range): SourceMap | undefined;
+export declare function reverseSourceMap(map: SourceMap | undefined): SourceMap | undefined;
+export {};
+//# sourceMappingURL=SourceMap.d.ts.map