@cspell/cspell-tools 6.31.1 → 7.0.0-alpha.2

package/bin.js

@@ -1,12 +1,10 @@
 #!/usr/bin/env node
 
-'use strict';
+import { program, CommanderError } from 'commander';
+import { run } from './dist/app.js';
 
-const app = require('./dist/app');
-const program = require('commander');
-
-app.run(program, process.argv).catch((e) => {
-    if (!(e instanceof program.CommanderError)) {
+run(program, process.argv).catch((e) => {
+    if (!(e instanceof CommanderError)) {
         console.log(e);
     }
     process.exitCode = 1;

package/dist/AppOptions.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=AppOptions.js.map

package/dist/FeatureFlags/FeatureFlags.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFeatureFlags = exports.getSystemFeatureFlags = exports.UnknownFeatureFlagError = exports.FeatureFlags = void 0;
 let systemFeatureFlags;
 /**
  * Feature Flags are used to turn on/off features.
  * These are primarily used before a feature has been fully released.
  */
-class FeatureFlags {
+export class FeatureFlags {
     constructor(flags = []) {
         this.flagValues = new Map();
         this.flags = new Map(flags.map((f) => [f.name, f]));
@@ -63,22 +60,18 @@ class FeatureFlags {
         return fork;
     }
 }
-exports.FeatureFlags = FeatureFlags;
-class UnknownFeatureFlagError extends Error {
+export class UnknownFeatureFlagError extends Error {
     constructor(flag) {
         super(`Unknown feature flag: ${flag}`);
         this.flag = flag;
     }
 }
-exports.UnknownFeatureFlagError = UnknownFeatureFlagError;
-function getSystemFeatureFlags() {
+export function getSystemFeatureFlags() {
     return systemFeatureFlags || (systemFeatureFlags = createFeatureFlags());
 }
-exports.getSystemFeatureFlags = getSystemFeatureFlags;
-function createFeatureFlags() {
+export function createFeatureFlags() {
     return new FeatureFlags();
 }
-exports.createFeatureFlags = createFeatureFlags;
 const boolValues = {
     0: false,
     1: true,

package/dist/FeatureFlags/index.d.ts

@@ -1,3 +1,3 @@
-export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags';
-export { parseFlags } from './parseFlags';
+export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags.js';
+export { parseFlags } from './parseFlags.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/FeatureFlags/index.js

@@ -1,10 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFlags = exports.UnknownFeatureFlagError = exports.getSystemFeatureFlags = exports.FeatureFlags = void 0;
-var FeatureFlags_1 = require("./FeatureFlags");
-Object.defineProperty(exports, "FeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.FeatureFlags; } });
-Object.defineProperty(exports, "getSystemFeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.getSystemFeatureFlags; } });
-Object.defineProperty(exports, "UnknownFeatureFlagError", { enumerable: true, get: function () { return FeatureFlags_1.UnknownFeatureFlagError; } });
-var parseFlags_1 = require("./parseFlags");
-Object.defineProperty(exports, "parseFlags", { enumerable: true, get: function () { return parseFlags_1.parseFlags; } });
+export { FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags.js';
+export { parseFlags } from './parseFlags.js';
 //# sourceMappingURL=index.js.map

package/dist/FeatureFlags/parseFlags.d.ts

@@ -1,3 +1,3 @@
-import type { FeatureFlags } from './FeatureFlags';
+import type { FeatureFlags } from './FeatureFlags.js';
 export declare function parseFlags(ff: FeatureFlags, flags: string[]): FeatureFlags;
 //# sourceMappingURL=parseFlags.d.ts.map

package/dist/FeatureFlags/parseFlags.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFlags = void 0;
-const FeatureFlags_1 = require("./FeatureFlags");
+import { UnknownFeatureFlagError } from './FeatureFlags.js';
 const splitFlag = /[:=]/;
 const leadingEql = /^=/;
-function parseFlags(ff, flags) {
+export function parseFlags(ff, flags) {
     for (const flag of flags) {
         const [name, value] = flag.replace(leadingEql, '').split(splitFlag, 2);
         try {
             ff.setFlag(name, value);
         }
         catch (e) {
-            if (e instanceof FeatureFlags_1.UnknownFeatureFlagError) {
+            if (e instanceof UnknownFeatureFlagError) {
                 console.error(e.message);
                 console.error(ff.help());
             }
@@ -20,5 +17,4 @@ function parseFlags(ff, flags) {
     }
     return ff;
 }
-exports.parseFlags = parseFlags;
 //# sourceMappingURL=parseFlags.js.map

package/dist/app.d.ts

@@ -1,4 +1,4 @@
 import type * as program from 'commander';
-import type { FeatureFlags } from './FeatureFlags';
+import type { FeatureFlags } from './FeatureFlags/index.js';
 export declare function run(program: program.Command, argv: string[], flags?: FeatureFlags): Promise<void>;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -1,38 +1,12 @@
-"use strict";
 // For large dictionaries, it is necessary to increase the memory limit.
-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.run = void 0;
-const path = __importStar(require("path"));
-const build_1 = require("./build");
-const compile_1 = require("./compile");
-const compiler = __importStar(require("./compiler"));
-const logWithTimestamp_1 = require("./compiler/logWithTimestamp");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const npmPackage = require(path.join(__dirname, '..', 'package.json'));
-compiler.setLogger(logWithTimestamp_1.logWithTimestamp);
+import { readFileSync } from 'fs';
+import { build } from './build.js';
+import { processCompileAction } from './compile.js';
+import * as compiler from './compiler/index.js';
+import { logWithTimestamp } from './compiler/logWithTimestamp.js';
+const npmPackageRaw = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+const npmPackage = JSON.parse(npmPackageRaw);
+compiler.setLogger(logWithTimestamp);
 function collect(value, previous) {
     return previous.concat([value]);
 }
@@ -51,27 +25,26 @@ function addCompileOptions(compileCommand) {
         .option('--trie4', 'Use file format trie4', false)
         .option('--trie-base <number>', 'Advanced: Set the trie base number. A value between 10 and 36');
 }
-async function run(program, argv, flags) {
+export async function run(program, argv, flags) {
     program.exitOverride();
     program.version(npmPackage.version);
     addCompileOptions(program.command('compile <src...>').description('Compile words into a cspell dictionary files.'))
         .option('--trie', 'Compile into a trie file.', false)
         .option('--no-sort', 'Do not sort the result')
         .action((src, options) => {
-        return (0, compile_1.processCompileAction)(src, options, flags);
+        return processCompileAction(src, options, flags);
     });
     addCompileOptions(program
         .command('compile-trie <src...>')
         .description('Compile words lists or Hunspell dictionary into trie files used by cspell.\nAlias of `compile --trie`')).action((src, options) => {
-        return (0, compile_1.processCompileAction)(src, { ...options, trie: true }, flags);
+        return processCompileAction(src, { ...options, trie: true }, flags);
     });
     program
         .command('build [targets]')
         .description('Build the targets defined in the run configuration.')
         .option('-c, --config <path to run configuration>', 'Specify the run configuration file.')
         .option('-r, --root <directory>', 'Specify the run directory')
-        .action(build_1.build);
+        .action(build);
     await program.parseAsync(argv);
 }
-exports.run = run;
 //# sourceMappingURL=app.js.map

package/dist/build.d.ts

@@ -1,7 +1,10 @@
 export interface BuildOptions {
     /** Optional path to config file */
-    config?: string;
-    root?: string;
+    config?: string | undefined;
+    /** Used to resolve relative paths in the config. */
+    root?: string | undefined;
+    /** Current working directory */
+    cwd?: string | undefined;
 }
 export declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
 //# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -1,33 +1,7 @@
-"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.build = void 0;
-const cosmiconfig_1 = require("cosmiconfig");
-const path = __importStar(require("path"));
-const compiler_1 = require("./compiler");
-const config_1 = require("./config");
+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';
 const searchPlaces = [
     `${moduleName}.config.json`,
@@ -35,25 +9,27 @@ const searchPlaces = [
     `${moduleName}.config.yml`,
     'package.json',
 ];
-async function build(targets, options) {
+export async function build(targets, options) {
     const allowedTargets = new Set(targets || []);
     function filter(target) {
         return !targets || allowedTargets.has(target.name);
     }
-    if (options.root) {
-        process.chdir(path.resolve(options.root));
-    }
-    const explorer = (0, cosmiconfig_1.cosmiconfig)(moduleName, {
+    const searchDir = path.resolve(options.root || options.cwd || '.');
+    const explorer = cosmiconfig(moduleName, {
         searchPlaces,
-        stopDir: path.resolve('.'),
-        transform: config_1.normalizeConfig,
+        stopDir: searchDir,
+        transform: normalizeConfig,
     });
-    const config = await (options.config ? explorer.load(options.config) : explorer.search('.'));
+    const config = await (options.config ? explorer.load(options.config) : explorer.search(searchDir));
     if (!config?.config) {
         console.error('root: %s', options.root);
         throw 'cspell-tools.config not found.';
     }
-    await (0, compiler_1.compile)(config.config, { filter });
+    const buildInfo = normalizeRequest(config.config, options.root || path.dirname(config.filepath));
+    await compile(buildInfo, { filter, cwd: options.cwd });
+}
+function normalizeRequest(buildInfo, root) {
+    const { rootDir = root, targets = [] } = buildInfo;
+    return { rootDir, targets };
 }
-exports.build = build;
 //# sourceMappingURL=build.js.map

package/dist/compile.d.ts

@@ -1,4 +1,4 @@
-import type { CompileCommonAppOptions } from './AppOptions';
-import type { FeatureFlags } from './FeatureFlags';
+import type { CompileCommonAppOptions } from './AppOptions.js';
+import type { FeatureFlags } from './FeatureFlags/index.js';
 export declare function processCompileAction(src: string[], options: CompileCommonAppOptions, featureFlags: FeatureFlags | undefined): Promise<void>;
 //# sourceMappingURL=compile.d.ts.map

package/dist/compile.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processCompileAction = void 0;
-const sync_1 = require("@cspell/cspell-pipe/sync");
-const compile_1 = require("./compiler/compile");
-const createCompileRequest_1 = require("./compiler/createCompileRequest");
-const globP_1 = require("./compiler/globP");
-const FeatureFlags_1 = require("./FeatureFlags");
-(0, FeatureFlags_1.getSystemFeatureFlags)().register('compound', 'Enable compound dictionary sources.');
-async function processCompileAction(src, options, featureFlags) {
-    const ff = featureFlags || (0, FeatureFlags_1.getSystemFeatureFlags)();
-    (0, FeatureFlags_1.parseFlags)(ff, options.experimental);
+import { opConcatMap, pipe } from '@cspell/cspell-pipe/sync';
+import { compile } from './compiler/compile.js';
+import { createCompileRequest } from './compiler/createCompileRequest.js';
+import { globP } from './compiler/globP.js';
+import { getSystemFeatureFlags, parseFlags } from './FeatureFlags/index.js';
+getSystemFeatureFlags().register('compound', 'Enable compound dictionary sources.');
+export async function processCompileAction(src, options, featureFlags) {
+    const ff = featureFlags || getSystemFeatureFlags();
+    parseFlags(ff, options.experimental);
     return useCompile(src, options);
 }
-exports.processCompileAction = processCompileAction;
 async function useCompile(src, options) {
     console.log('Compile:\n output: %s\n compress: %s\n files:\n  %s \n\n', options.output || 'default', options.compress ? 'true' : 'false', src.join('\n  '));
-    const globResults = await Promise.all(src.map((s) => (0, globP_1.globP)(s)));
+    const globResults = await Promise.all(src.map((s) => globP(s)));
     const sources = [
-        ...(0, sync_1.pipe)(globResults, (0, sync_1.opConcatMap)((a) => a)),
+        ...pipe(globResults, opConcatMap((a) => a)),
     ];
-    return (0, compile_1.compile)((0, createCompileRequest_1.createCompileRequest)(sources, options));
+    return compile(createCompileRequest(sources, options));
 }
 //# sourceMappingURL=compile.js.map

package/dist/compiler/CompileOptions.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=CompileOptions.js.map

package/dist/compiler/Reader.d.ts

@@ -1,4 +1,4 @@
-import type { Reader, ReaderOptions } from './readers/ReaderOptions';
+import type { Reader, ReaderOptions } from './readers/ReaderOptions.js';
 export declare const regHunspellFile: RegExp;
 export declare function createReader(filename: string, options: ReaderOptions): Promise<Reader>;
 //# sourceMappingURL=Reader.d.ts.map

package/dist/compiler/Reader.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReader = exports.regHunspellFile = void 0;
-const readHunspellFiles_1 = require("./readers/readHunspellFiles");
-const textFileReader_1 = require("./readers/textFileReader");
-const trieFileReader_1 = require("./readers/trieFileReader");
-exports.regHunspellFile = /\.(dic|aff)$/i;
+import { readHunspellFiles } from './readers/readHunspellFiles.js';
+import { textFileReader } from './readers/textFileReader.js';
+import { trieFileReader } from './readers/trieFileReader.js';
+export const regHunspellFile = /\.(dic|aff)$/i;
 // Readers first match wins
 const readers = [
-    { test: /\.trie\b/, method: trieFileReader_1.trieFileReader },
-    { test: exports.regHunspellFile, method: readHunspellFiles_1.readHunspellFiles },
+    { test: /\.trie\b/, method: trieFileReader },
+    { test: regHunspellFile, method: readHunspellFiles },
 ];
 function findMatchingReader(filename, options) {
     for (const reader of readers) {
@@ -16,13 +13,12 @@ function findMatchingReader(filename, options) {
             return reader.method(filename, options);
         }
     }
-    return (0, textFileReader_1.textFileReader)(filename);
+    return textFileReader(filename);
 }
-async function createReader(filename, options) {
+export async function createReader(filename, options) {
     const baseReader = await findMatchingReader(filename, options);
     return Object.assign(baseReader, {
         [Symbol.iterator]: () => baseReader.lines[Symbol.iterator](),
     });
 }
-exports.createReader = createReader;
 //# sourceMappingURL=Reader.js.map

package/dist/compiler/SourceReader.d.ts

@@ -1,4 +1,4 @@
-import type { AllowedSplitWordsCollection } from './WordsCollection';
+import type { AllowedSplitWordsCollection } from './WordsCollection.js';
 export interface SourceReaderOptions {
     /**
      * Max Hunspell recursive depth.

package/dist/compiler/SourceReader.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSourceReader = void 0;
-const Reader_1 = require("./Reader");
-const wordListParser_1 = require("./wordListParser");
-async function createSourceReader(filename, options) {
-    const reader = await (0, Reader_1.createReader)(filename, options);
+import { createReader } from './Reader.js';
+import { parseFileLines } from './wordListParser.js';
+export async function createSourceReader(filename, options) {
+    const reader = await createReader(filename, options);
     if (reader.type !== 'TextFile') {
         return {
             words: reader.lines,
@@ -15,10 +12,9 @@ async function createSourceReader(filename, options) {
     }
     return textFileReader(reader, options);
 }
-exports.createSourceReader = createSourceReader;
 async function textFileReader(reader, options) {
     const { legacy, splitWords: split, allowedSplitWords } = options;
-    const words = [...(0, wordListParser_1.parseFileLines)(reader, { legacy, split, allowedSplitWords })];
+    const words = [...parseFileLines(reader, { legacy, split, allowedSplitWords })];
     return {
         size: words.length,
         words,

package/dist/compiler/WordsCollection.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultExcludeWordsCollection = exports.defaultAllowedSplitWords = void 0;
-exports.defaultAllowedSplitWords = Object.freeze({ size: 0, has: () => true });
-exports.defaultExcludeWordsCollection = Object.freeze({ size: 0, has: () => false });
+export const defaultAllowedSplitWords = Object.freeze({ size: 0, has: () => true });
+export const defaultExcludeWordsCollection = Object.freeze({ size: 0, has: () => false });
 //# sourceMappingURL=WordsCollection.js.map

package/dist/compiler/compile.d.ts

@@ -1,11 +1,15 @@
-import type { CompileRequest, CompileSourceOptions, Target } from '../config';
+import type { CompileRequest, CompileSourceOptions, Target } from '../config/index.js';
 interface CompileOptions {
     /**
      * Optional filter function to filter targets.
      */
     filter?: (target: Target) => boolean;
+    /**
+     * The current working directory. Defaults to process.cwd()
+     */
+    cwd?: string;
 }
 export declare function compile(request: CompileRequest, options?: CompileOptions): Promise<void>;
-export declare function compileTarget(target: Target, options: CompileSourceOptions, rootDir: string): Promise<void>;
+export declare function compileTarget(target: Target, options: CompileSourceOptions, rootDir: string, cwd?: string): Promise<void>;
 export {};
 //# sourceMappingURL=compile.d.ts.map