@cspell/cspell-tools 8.7.0 → 8.8.1

package/bin.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import { program, CommanderError } from 'commander';
+import { CommanderError, program } from 'commander';
+
 import { run } from './dist/app.js';
 
 run(program, process.argv).catch((e) => {

package/dist/app.js

@@ -1,6 +1,6 @@
 // For large dictionaries, it is necessary to increase the memory limit.
+import { readFileSync } from 'node:fs';
 import { CommanderError, Option } from 'commander';
-import { readFileSync } from 'fs';
 import { build } from './build.js';
 import { processCompileAction } from './compile.js';
 import * as compiler from './compiler/index.js';
@@ -12,7 +12,7 @@ const npmPackageRaw = readFileSync(new URL('../package.json', import.meta.url),
 const npmPackage = JSON.parse(npmPackageRaw);
 compiler.setLogger(logWithTimestamp);
 function collect(value, previous) {
-    return previous.concat([value]);
+    return [...previous, value];
 }
 function addCompileOptions(compileCommand) {
     return compileCommand

package/dist/build.js

@@ -1,5 +1,5 @@
+import * as path from 'node:path';
 import { cosmiconfig } from 'cosmiconfig';
-import * as path from 'path';
 import { compile } from './compiler/index.js';
 import { normalizeConfig } from './config/index.js';
 const moduleName = 'cspell-tools';

package/dist/compile.js

@@ -15,7 +15,7 @@ export async function processCompileAction(src, options, featureFlags) {
     return useCompile(src, options);
 }
 async function useCompile(src, options) {
-    console.log('Compile:\n output: %s\n compress: %s\n files:\n  %s ', options.output || 'default', options.compress ? 'true' : 'false', src.join('\n  '));
+    console.log('Compile:\n output: %s\n compress: %s\n files:\n  %s', options.output || 'default', options.compress ? 'true' : 'false', src.join('\n  '));
     if (options.listFile && options.listFile.length) {
         console.log(' list files:\n  %s', options.listFile.join('\n  '));
     }
@@ -30,7 +30,7 @@ async function useCompile(src, options) {
 async function initConfig(runConfig) {
     const { $schema = configFileSchemaURL, ...cfg } = runConfig;
     const config = { $schema, ...cfg };
-    const content = configFileHeader + YAML.stringify(config, null, 2);
+    const content = configFileHeader + YAML.stringify(config, undefined, 2);
     console.log('Writing config file: %s', defaultConfigFile);
     await writeFile(defaultConfigFile, content);
     console.log(`Init complete.

package/dist/compiler/compile.js

@@ -1,7 +1,7 @@
+import * as path from 'node:path';
 import { pipeAsync, toArray } from '@cspell/cspell-pipe';
 import { opAwaitAsync, opMapAsync } from '@cspell/cspell-pipe/operators';
 import { opConcatMap, opMap, pipe } from '@cspell/cspell-pipe/sync';
-import * as path from 'path';
 import { isFileListSource, isFilePath, isFileSource } from '../config/index.js';
 import { checkShasumFile, updateChecksumForFiles } from '../shasum/index.js';
 import { createAllowedSplitWordsFromFiles, createWordsCollectionFromFiles } from './createWordsCollection.js';
@@ -173,9 +173,9 @@ async function readFileSource(fileSource, sourceOptions) {
     return f;
 }
 function normalizeTargetName(name) {
-    return name.replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '').replace(/[^\p{L}\p{M}.\w\\/-]/gu, '_');
+    return name.replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '').replaceAll(/[^\p{L}\p{M}.\w\\/-]/gu, '_');
 }
-function logProgress(freq = 100000) {
+function logProgress(freq = 100_000) {
     function* logProgress(iter) {
         const _freq = freq;
         let count = 0;

package/dist/compiler/createCompileRequest.js

@@ -1,4 +1,4 @@
-import * as path from 'path';
+import * as path from 'node:path';
 export function createCompileRequest(sourceFiles, options) {
     options = { ...options };
     options.maxDepth ??= options.max_depth;
@@ -59,8 +59,8 @@ function toTargetName(sourceFile) {
     return path.basename(sourceFile).replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '');
 }
 function parseNumber(s) {
-    const n = parseInt(s ?? '');
-    return isNaN(n) ? undefined : n;
+    const n = Number.parseInt(s ?? '');
+    return Number.isNaN(n) ? undefined : n;
 }
 function baseNameOfSource(source) {
     return typeof source === 'string' ? source : isFileSource(source) ? source.filename : source.listFile;

package/dist/compiler/createWordsCollection.js

@@ -33,7 +33,7 @@ export async function createWordsCollectionFromFiles(files) {
     if (cached)
         return cached;
     const sources = await Promise.all(files.map((file) => readFile(file)));
-    const collection = createWordsCollection(sources.flatMap((a) => a));
+    const collection = createWordsCollection(sources.flat());
     cache.set(files, collection);
     return collection;
 }

package/dist/compiler/legacyLineToWords.js

@@ -4,9 +4,9 @@ const regNonWord = /[^\p{L}\p{M}' _\d]+/giu;
 const regExpRepeatChars = /(.)\1{5}/i;
 export function legacyLineToWords(line, keepCase, allowedSplitWords) {
     // Remove punctuation and non-letters.
-    const filteredLine = line.replace(regNonWord, '|');
+    const filteredLine = line.replaceAll(regNonWord, '|');
     const wordGroups = filteredLine.split('|');
-    const words = pipe(wordGroups, opConcatMap((a) => [...a.split(regExpSpaceOrDash)]), opConcatMap((a) => splitCamelCaseIfAllowed(a, allowedSplitWords, keepCase)), opMap((a) => a.trim()), opFilter((a) => !!a), opFilter((s) => !regExpRepeatChars.test(s)));
+    const words = pipe(wordGroups, opConcatMap((a) => a.split(regExpSpaceOrDash)), opConcatMap((a) => splitCamelCaseIfAllowed(a, allowedSplitWords, keepCase)), opMap((a) => a.trim()), opFilter((a) => !!a), opFilter((s) => !regExpRepeatChars.test(s)));
     return words;
 }
 export function* legacyLinesToWords(lines, keepCase, allowedSplitWords) {

package/dist/compiler/readers/readTextFile.js

@@ -1,5 +1,5 @@
-import assert from 'assert';
-import { promises as fs } from 'fs';
+import assert from 'node:assert';
+import { promises as fs } from 'node:fs';
 import { decompress } from '../../gzip/index.js';
 const isGzFile = /\.gz$/;
 export function readTextFile(filename) {

package/dist/compiler/text.js

@@ -6,10 +6,10 @@ const regExSplitWords2 = /(\p{Lu})(\p{Lu}\p{Ll})/gu;
  * Split camelCase words into an array of strings.
  */
 export function splitCamelCaseWord(word, autoStem = true) {
-    const wPrime = autoStem ? word.replace(regExUpperSOrIng, (s) => s[0] + s.slice(1).toLowerCase()) : word;
-    const pass1 = wPrime.replace(regExSplitWords, '$1|$2');
-    const pass2 = pass1.replace(regExSplitWords2, '$1|$2');
-    const pass3 = pass2.replace(/[\d_]+/g, '|');
+    const wPrime = autoStem ? word.replaceAll(regExUpperSOrIng, (s) => s[0] + s.slice(1).toLowerCase()) : word;
+    const pass1 = wPrime.replaceAll(regExSplitWords, '$1|$2');
+    const pass2 = pass1.replaceAll(regExSplitWords2, '$1|$2');
+    const pass3 = pass2.replaceAll(/[\d_]+/g, '|');
     return pass3.split('|').filter((a) => !!a);
 }
 //# sourceMappingURL=text.js.map

package/dist/compiler/wordListCompiler.js

@@ -1,7 +1,7 @@
+import { mkdir } from 'node:fs/promises';
+import * as path from 'node:path';
 import { opAppend, opMap, pipe } from '@cspell/cspell-pipe/sync';
 import * as Trie from 'cspell-trie-lib';
-import { mkdir } from 'fs/promises';
-import * as path from 'path';
 import { writeSeqToFile } from './fileWriter.js';
 import { getLogger } from './logger.js';
 import { normalizeTargetWords } from './wordListParser.js';

package/dist/compiler/wordListParser.js

@@ -11,8 +11,8 @@ export function normalizeTargetWords(options) {
     const operations = [
         opFilter((a) => !!a),
         lineParser,
-        options.sort ? createInlineBufferedSort(10000) : undefined,
-        opFilter(uniqueFilter(10000)),
+        options.sort ? createInlineBufferedSort(10_000) : undefined,
+        opFilter(uniqueFilter(10_000)),
         options.filter ? opFilter(options.filter) : undefined,
     ].filter(isDefined);
     return opCombine(...operations);
@@ -78,23 +78,28 @@ export function createParseFileLineMapper(options) {
                 .filter((a) => !!a);
             for (const flag of flags) {
                 switch (flag) {
-                    case 'split':
+                    case 'split': {
                         split = true;
                         break;
-                    case 'no-split':
+                    }
+                    case 'no-split': {
                         split = false;
                         break;
-                    case 'keep-case':
+                    }
+                    case 'keep-case': {
                         keepCase = true;
                         legacy = false;
                         break;
-                    case 'no-keep-case':
+                    }
+                    case 'no-keep-case': {
                         keepCase = false;
                         break;
-                    case 'legacy':
+                    }
+                    case 'legacy': {
                         keepCase = false;
                         legacy = true;
                         break;
+                    }
                 }
             }
         }
@@ -107,23 +112,23 @@ export function createParseFileLineMapper(options) {
     function splitLine(line) {
         line = line.replace(/#.*/, ''); // remove comment
         line = line.trim();
-        line = line.replace(/\bU\+[0-9A-F]{4}\b/gi, '|'); // Remove Unicode Definitions
-        line = line.replace(/\\U[0-9A-F]{4}/gi, '|'); // Remove Unicode Definitions
-        line = line.replace(regNonWordOrDigit, '|');
-        line = line.replace(/'(?=\|)/g, ''); // remove trailing '
+        line = line.replaceAll(/\bU\+[0-9A-F]{4}\b/gi, '|'); // Remove Unicode Definitions
+        line = line.replaceAll(/\\U[0-9A-F]{4}/gi, '|'); // Remove Unicode Definitions
+        line = line.replaceAll(regNonWordOrDigit, '|');
+        line = line.replaceAll(/'(?=\|)/g, ''); // remove trailing '
         line = line.replace(/'$/, ''); // remove trailing '
-        line = line.replace(/(?<=\|)'/g, ''); // remove leading '
+        line = line.replaceAll(/(?<=\|)'/g, ''); // remove leading '
         line = line.replace(/^'/, ''); // remove leading '
-        line = line.replace(/\s*\|\s*/g, '|'); // remove spaces around |
-        line = line.replace(/[|]+/g, '|'); // reduce repeated |
+        line = line.replaceAll(/\s*\|\s*/g, '|'); // remove spaces around |
+        line = line.replaceAll(/[|]+/g, '|'); // reduce repeated |
         line = line.replace(/^\|/, ''); // remove leading |
         line = line.replace(/\|$/, ''); // remove trailing |
         const lines = line
             .split('|')
             .map((a) => a.trim())
             .filter((a) => !!a)
-            .filter((a) => !a.match(/^[0-9_-]+$/)) // pure numbers and symbols
-            .filter((a) => !a.match(/^0[xo][0-9A-F]+$/i)); // c-style hex/octal digits
+            .filter((a) => !/^[0-9_-]+$/.test(a)) // pure numbers and symbols
+            .filter((a) => !/^0[xo][0-9A-F]+$/i.test(a)); // c-style hex/octal digits
         return lines;
     }
     function* splitWords(lines) {
@@ -134,16 +139,13 @@ export function createParseFileLineMapper(options) {
             }
             if (split) {
                 const words = splitLine(line);
-                if (!allowedSplitWords.size) {
-                    yield* words;
-                }
-                else {
-                    yield* words.flatMap((word) => splitCamelCaseIfAllowed(word, allowedSplitWords, keepCase));
-                }
+                yield* !allowedSplitWords.size
+                    ? words
+                    : words.flatMap((word) => splitCamelCaseIfAllowed(word, allowedSplitWords, keepCase));
                 if (!splitKeepBoth)
                     continue;
             }
-            yield line.replace(/["]/g, '');
+            yield line.replaceAll(/["]/g, '');
         }
     }
     function* unique(lines) {

package/dist/compiler/writeTextToFile.js

@@ -1,9 +1,9 @@
-import { promises as fs } from 'fs';
+import { promises as fs } from 'node:fs';
 import { compress } from '../gzip/index.js';
 const isGzFile = /\.gz$/;
 export async function writeTextToFile(filename, data) {
     const useGz = isGzFile.test(filename);
-    const buf = Buffer.from(data, 'utf-8');
+    const buf = Buffer.from(data, 'utf8');
     const buffer = useGz ? await compress(buf) : buf;
     await fs.writeFile(filename, buffer);
 }

package/dist/config/config.d.ts

@@ -86,7 +86,7 @@ export interface Target extends CompileTargetOptions {
      * Words from the sources that are found in `excludeWordsFrom` files
      * will not be added to the dictionary.
      *
-     * @version 8.3.2
+     * @since 8.3.2
      */
     excludeWordsFrom?: FilePath[] | undefined;
     /**

package/dist/config/normalizeConfig.js

@@ -1,4 +1,4 @@
-import * as path from 'path';
+import * as path from 'node:path';
 export function normalizeConfig(cfg) {
     if (!cfg)
         return cfg;

package/dist/shasum/shasum.js

@@ -9,8 +9,10 @@ export async function shasumFile(filename, root) {
         const checksum = await calcFileChecksum(file);
         return `${checksum}  ${filename}`;
     }
-    catch (error) {
+    catch {
         // const err = toError(error);
+        // Reject with a string.
+        // eslint-disable-next-line unicorn/no-useless-promise-resolve-reject
         return Promise.reject(`shasum: ${filename}: Unable to read file.`);
     }
 }
@@ -29,7 +31,7 @@ export async function checkShasumFile(filename, files, root) {
     const results = await Promise.all(filesToCheck.map(normalizeFilename).map((filename) => {
         return tryToCheckFile(filename, resolvedRoot, mapNameToChecksum.get(filename));
     }));
-    const passed = !results.find((v) => !v.passed);
+    const passed = !results.some((v) => !v.passed);
     return { passed, results };
 }
 async function tryToCheckFile(filename, root, checksum) {
@@ -41,7 +43,7 @@ async function tryToCheckFile(filename, root, checksum) {
         const passed = await checkFile(checksum, file);
         return { filename, passed };
     }
-    catch (error) {
+    catch {
         return { filename, passed: false, error: Error('Failed to read file.') };
     }
 }

package/dist/test/TestHelper.js

@@ -1,7 +1,7 @@
-import assert from 'assert';
-import { mkdirSync, promises as fs, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
+import assert from 'node:assert';
+import { mkdirSync, promises as fs, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { expect } from 'vitest';
 const _dirname = test_dirname(import.meta.url);
 const packageRoot = path.join(_dirname, '../..');
@@ -50,7 +50,7 @@ class TestHelperImpl {
      */
     resolveTemp(...parts) {
         const currentTestName = this.getCurrentTestName();
-        const testName = currentTestName.replace(/[^\w_.-]/g, '_');
+        const testName = currentTestName.replaceAll(/[^\w_.-]/g, '_');
         return path.resolve(this.tempDir, testName, ...parts);
     }
     /**
@@ -96,7 +96,7 @@ class TestHelperImpl {
             await fs.stat(path);
             return true;
         }
-        catch (e) {
+        catch {
             return false;
         }
     }

package/dist/test/escapeRegEx.js

@@ -4,6 +4,6 @@
  * @returns - the escaped string.
  */
 export function escapeRegEx(s) {
-    return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+    return s.replaceAll(/[|\\{}()[\]^$+*?.]/g, '\\$&').replaceAll('-', '\\x2d');
 }
 //# sourceMappingURL=escapeRegEx.js.map

package/dist/test/normalizeOutput.js

@@ -1,4 +1,4 @@
-import * as path from 'path';
+import * as path from 'node:path';
 import { escapeRegEx } from './escapeRegEx.js';
 import { test_dirname } from './TestHelper.js';
 const _dirname = test_dirname(import.meta.url);
@@ -12,9 +12,9 @@ const rxRootRepo = new RegExp(escapeRegEx(rootRepo) + '|' + escapeRegEx(normaliz
 export function normalizeOutput(output, cwd = process.cwd()) {
     const rxCwd = new RegExp(escapeRegEx(cwd) + '|' + escapeRegEx(normalizeDirectorySeparator(cwd)), 'gi');
     const normalizeDirs = normalizeDirectorySeparator(output.replace(rxCwd, '{cwd}').replace(rxRootRepo, '{repo-root}'));
-    return normalizeDirs.replace(regexpDate, '2022-01-01T00:00:00.000Z');
+    return normalizeDirs.replaceAll(regexpDate, '2022-01-01T00:00:00.000Z');
 }
 export function normalizeDirectorySeparator(path) {
-    return path.replace(/\\/g, '/');
+    return path.replaceAll('\\', '/');
 }
 //# sourceMappingURL=normalizeOutput.js.map

package/dist/util/globP.js

@@ -1,7 +1,7 @@
 import { glob } from 'glob';
 export function globP(pattern, options) {
     // Convert windows separators.
-    const globs = (Array.isArray(pattern) ? pattern : [pattern]).map((pattern) => pattern.replace(/\\/g, '/'));
+    const globs = (Array.isArray(pattern) ? pattern : [pattern]).map((pattern) => pattern.replaceAll('\\', '/'));
     return glob(globs, options);
 }
 //# sourceMappingURL=globP.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspell/cspell-tools",
-  "version": "8.7.0",
+  "version": "8.8.1",
   "description": "Tools to assist with the development of cSpell",
   "publishConfig": {
     "access": "public"
@@ -50,14 +50,14 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "8.7.0",
+    "@cspell/cspell-pipe": "8.8.1",
     "commander": "^12.0.0",
     "cosmiconfig": "9.0.0",
-    "cspell-trie-lib": "8.7.0",
+    "cspell-trie-lib": "8.8.1",
     "gensequence": "^7.0.0",
-    "glob": "^10.3.12",
-    "hunspell-reader": "8.7.0",
-    "yaml": "^2.4.1"
+    "glob": "^10.3.14",
+    "hunspell-reader": "8.8.1",
+    "yaml": "^2.4.2"
   },
   "engines": {
     "node": ">=18"
@@ -65,8 +65,8 @@
   "devDependencies": {
     "@types/glob": "^8.1.0",
     "lorem-ipsum": "^2.0.8",
-    "ts-json-schema-generator": "^1.5.1"
+    "ts-json-schema-generator": "^2.1.1"
   },
   "module": "bin.mjs",
-  "gitHead": "5318079ed11fe77e981287ecf1c40d6f28dd91ed"
+  "gitHead": "6381846ffce8b9a349bfda03262297aa8e301ef5"
 }