@cspell/cspell-tools 6.11.1 → 6.13.0

package/dist/AppOptions.d.ts

@@ -0,0 +1,28 @@
+export interface CompileCommonAppOptions {
+    output?: string;
+    compress: boolean;
+    /**
+     * @deprecated Use maxDepth
+     */
+    max_depth?: string;
+    maxDepth?: string;
+    merge?: string;
+    experimental: string[];
+    split?: boolean;
+    sort?: boolean;
+    keepRawCase?: boolean;
+    trie?: boolean;
+    trie3?: boolean;
+    trie4?: boolean;
+    trieBase?: string;
+    useLegacySplitter?: boolean;
+}
+export interface CompileAppOptions extends CompileCommonAppOptions {
+    sort: boolean;
+    keepRawCase: boolean;
+}
+export interface CompileTrieAppOptions extends CompileCommonAppOptions {
+    trie3: boolean;
+    trie4: boolean;
+}
+//# sourceMappingURL=AppOptions.d.ts.map

package/dist/AppOptions.js

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

package/dist/FeatureFlags/FeatureFlags.d.ts

@@ -0,0 +1,34 @@
+export interface FeatureFlag {
+    name: string;
+    description: string;
+}
+declare type FlagTypes = string | boolean;
+/**
+ * Feature Flags are used to turn on/off features.
+ * These are primarily used before a feature has been fully released.
+ */
+export declare class FeatureFlags {
+    private flags;
+    private flagValues;
+    constructor(flags?: FeatureFlag[]);
+    register(flag: FeatureFlag): this;
+    register(name: string, description: string): this;
+    registerFeatures(flags: FeatureFlag[]): this;
+    getFlag(flag: string): FlagTypes | undefined;
+    getFlagBool(flag: string): boolean | undefined;
+    setFlag(flag: string, value?: FlagTypes): this;
+    getFlagInfo(flag: string): FeatureFlag | undefined;
+    getFlags(): FeatureFlag[];
+    getFlagValues(): Map<string, FlagTypes>;
+    reset(): this;
+    help(): string;
+    fork(): FeatureFlags;
+}
+export declare class UnknownFeatureFlagError extends Error {
+    readonly flag: string;
+    constructor(flag: string);
+}
+export declare function getSystemFeatureFlags(): FeatureFlags;
+export declare function createFeatureFlags(): FeatureFlags;
+export {};
+//# sourceMappingURL=FeatureFlags.d.ts.map

package/dist/FeatureFlags/FeatureFlags.js

@@ -0,0 +1,99 @@
+"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 {
+    constructor(flags = []) {
+        this.flagValues = new Map();
+        this.flags = new Map(flags.map((f) => [f.name, f]));
+    }
+    register(flagOrName, description) {
+        if (typeof flagOrName === 'string') {
+            return this.register({ name: flagOrName, description: description || '' });
+        }
+        this.flags.set(flagOrName.name, flagOrName);
+        return this;
+    }
+    registerFeatures(flags) {
+        flags.forEach((flag) => this.register(flag));
+        return this;
+    }
+    getFlag(flag) {
+        return this.flagValues.get(flag);
+    }
+    getFlagBool(flag) {
+        return toBool(this.getFlag(flag));
+    }
+    setFlag(flag, value = true) {
+        if (!this.flags.has(flag)) {
+            throw new UnknownFeatureFlagError(flag);
+        }
+        this.flagValues.set(flag, toBool(value) ?? value);
+        return this;
+    }
+    getFlagInfo(flag) {
+        return this.flags.get(flag);
+    }
+    getFlags() {
+        return [...this.flags.values()];
+    }
+    getFlagValues() {
+        return new Map(this.flagValues);
+    }
+    reset() {
+        this.flagValues.clear();
+        return this;
+    }
+    help() {
+        const flags = [{ name: 'Name', description: 'Description' }, ...this.flags.values()].sort((a, b) => a.name < b.name ? -1 : 1);
+        const nameColWidth = flags.map((f) => f.name.length).reduce((a, b) => Math.max(a, b), 0) + 1;
+        const entries = flags.map((f) => `- ${f.name}${' '.repeat(nameColWidth - f.name.length)} ${f.description}`);
+        const text = `Valid Flags:\n${entries.join('\n')}`;
+        return text;
+    }
+    fork() {
+        const fork = new FeatureFlags([...this.flags.values()]);
+        for (const [key, value] of this.flagValues) {
+            fork.flagValues.set(key, value);
+        }
+        return fork;
+    }
+}
+exports.FeatureFlags = FeatureFlags;
+class UnknownFeatureFlagError extends Error {
+    constructor(flag) {
+        super(`Unknown feature flag: ${flag}`);
+        this.flag = flag;
+    }
+}
+exports.UnknownFeatureFlagError = UnknownFeatureFlagError;
+function getSystemFeatureFlags() {
+    return systemFeatureFlags || (systemFeatureFlags = createFeatureFlags());
+}
+exports.getSystemFeatureFlags = getSystemFeatureFlags;
+function createFeatureFlags() {
+    return new FeatureFlags();
+}
+exports.createFeatureFlags = createFeatureFlags;
+const boolValues = {
+    0: false,
+    1: true,
+    f: false,
+    false: false,
+    n: false,
+    no: false,
+    t: true,
+    true: true,
+    y: true,
+    yes: true,
+};
+function toBool(value) {
+    if (typeof value !== 'string')
+        return value;
+    return boolValues[value.toLowerCase()];
+}
+//# sourceMappingURL=FeatureFlags.js.map

package/dist/FeatureFlags/index.d.ts

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

package/dist/FeatureFlags/index.js

@@ -0,0 +1,10 @@
+"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; } });
+//# sourceMappingURL=index.js.map

package/dist/FeatureFlags/parseFlags.d.ts

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

package/dist/FeatureFlags/parseFlags.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlags = void 0;
+const FeatureFlags_1 = require("./FeatureFlags");
+const splitFlag = /[:=]/;
+const leadingEql = /^=/;
+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) {
+                console.error(e.message);
+                console.error(ff.help());
+            }
+            throw e;
+        }
+    }
+    return ff;
+}
+exports.parseFlags = parseFlags;
+//# sourceMappingURL=parseFlags.js.map

package/dist/app.d.ts

@@ -1,23 +1,4 @@
 import * as program from 'commander';
-interface CompileCommonOptions {
-    output?: string;
-    compress: boolean;
-    max_depth?: string;
-    merge?: string;
-    experimental: string[];
-    split?: boolean;
-    sort?: boolean;
-    keepRawCase?: boolean;
-    trie?: boolean;
-    trie3?: boolean;
-    trie4?: boolean;
-    trieBase?: string;
-    useLegacySplitter?: boolean;
-}
-export declare function run(program: program.Command, argv: string[]): Promise<void>;
-declare function processAction(src: string[], options: CompileCommonOptions): Promise<void>;
-export declare const __testing__: {
-    processAction: typeof processAction;
-};
-export {};
+import { FeatureFlags } from './FeatureFlags';
+export declare function run(program: program.Command, argv: string[], flags?: FeatureFlags): Promise<void>;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -23,33 +23,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.run = void 0;
-const compiler_1 = require("./compiler");
-const compiler = __importStar(require("./compiler"));
+exports.run = void 0;
 const path = __importStar(require("path"));
-const glob_1 = __importDefault(require("glob"));
-const gensequence_1 = require("gensequence");
-const iterateWordsFromFile_1 = require("./compiler/iterateWordsFromFile");
+const compiler = __importStar(require("./compiler"));
+const logWithTimestamp_1 = require("./compiler/logWithTimestamp");
+const compile_1 = require("./compile");
+const build_1 = require("./build");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const npmPackage = require(path.join(__dirname, '..', 'package.json'));
-function globP(pattern) {
-    // Convert windows separators.
-    pattern = pattern.replace(/\\/g, '/');
-    return new Promise((resolve, reject) => {
-        (0, glob_1.default)(pattern, (err, result) => {
-            err ? reject(err) : resolve(result);
-        });
-    });
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const log = (message, ...optionalParams) => {
-    console.log(`${new Date().toISOString()} ${message}`, ...optionalParams);
-};
-compiler.setLogger(log);
+compiler.setLogger(logWithTimestamp_1.logWithTimestamp);
 function collect(value, previous) {
     return previous.concat([value]);
 }
@@ -68,129 +51,27 @@ 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');
 }
-function run(program, argv) {
+async function run(program, argv, flags) {
     program.exitOverride();
-    return new Promise((resolve, reject) => {
-        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) => {
-            const result = processAction(src, options);
-            resolve(result);
-        });
-        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) => {
-            const result = processAction(src, { ...options, trie: true });
-            resolve(result);
-        });
-        try {
-            program.parse(argv);
-            if (!argv.slice(2).length) {
-                program.help();
-            }
-        }
-        catch (e) {
-            reject(e);
-        }
-        resolve();
-    });
-}
-exports.run = run;
-function parseNumber(s) {
-    const n = parseInt(s ?? '');
-    return isNaN(n) ? undefined : n;
-}
-async function processAction(src, options) {
-    const useTrie = options.trie || options.trie3 || options.trie4 || false;
-    const fileExt = useTrie ? '.trie' : '.txt';
-    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 experimental = new Set(options.experimental);
-    const skipNormalization = experimental.has('compound');
-    const { keepRawCase = false, split: splitWords = false, sort = true, useLegacySplitter: legacy } = options;
-    const action = useTrie
-        ? async (words, dst) => {
-            return (0, compiler_1.compileTrie)(words, dst, {
-                ...options,
-                skipNormalization,
-                splitWords,
-                keepRawCase,
-                legacy,
-                base: parseNumber(options.trieBase),
-                sort: false,
-            });
-        }
-        : async (src, dst) => {
-            return (0, compiler_1.compileWordList)(src, dst, {
-                splitWords,
-                sort,
-                skipNormalization,
-                keepRawCase,
-                legacy,
-            }).then(() => src);
-        };
-    const ext = fileExt + (options.compress ? '.gz' : '');
-    const maxDepth = parseNumber(options.max_depth);
-    const useAnnotation = experimental.has('compound');
-    const readerOptions = { maxDepth, useAnnotation };
-    const globResults = await Promise.all(src.map((s) => globP(s)));
-    const filesToProcess = (0, gensequence_1.genSequence)(globResults)
-        .concatMap((files) => files)
-        .map(async (filename) => {
-        log(`Reading ${path.basename(filename)}`);
-        const words = await (0, iterateWordsFromFile_1.streamWordsFromFile)(filename, readerOptions);
-        log(`Done reading ${path.basename(filename)}`);
-        const f = {
-            src: filename,
-            words,
-        };
-        return f;
+    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);
     });
-    const r = options.merge
-        ? processFiles(action, filesToProcess, toMergeTargetFile(options.merge, options.output, ext))
-        : processFilesIndividually(action, filesToProcess, (s) => toTargetFile(s, options.output, ext));
-    await r;
-    log(`Complete.`);
-}
-function toFilename(name, ext) {
-    return path.basename(name).replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '') + ext;
-}
-function toTargetFile(filename, destination, ext) {
-    const outFileName = toFilename(filename, ext);
-    const dir = destination ?? path.dirname(filename);
-    return path.join(dir, outFileName);
-}
-function toMergeTargetFile(filename, destination, ext) {
-    const outFileName = path.join(path.dirname(filename), toFilename(filename, ext));
-    return path.resolve(destination ?? '.', outFileName);
-}
-async function processFilesIndividually(action, filesToProcess, srcToTarget) {
-    const toProcess = filesToProcess.map(async (pFtp) => {
-        const { src, words } = await pFtp;
-        const dst = srcToTarget(src);
-        log('Process "%s" to "%s"', src, dst);
-        await action(words, dst);
-        log('Done "%s" to "%s"', src, dst);
+    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);
     });
-    for (const p of toProcess) {
-        await p;
-    }
-}
-async function processFiles(action, filesToProcess, mergeTarget) {
-    const toProcess = await Promise.all([...filesToProcess]);
-    const dst = mergeTarget;
-    const words = (0, gensequence_1.genSequence)(toProcess)
-        .map((ftp) => {
-        const { src } = ftp;
-        log('Process "%s" to "%s"', src, dst);
-        return ftp;
-    })
-        .concatMap((ftp) => ftp.words);
-    await action(words, dst);
-    log('Done "%s"', dst);
+    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);
+    await program.parseAsync(argv);
 }
-exports.__testing__ = {
-    processAction,
-};
+exports.run = run;
 //# sourceMappingURL=app.js.map

package/dist/build.d.ts

@@ -0,0 +1,7 @@
+export interface BuildOptions {
+    /** Optional path to config file */
+    config?: string;
+    root?: string;
+}
+export declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -0,0 +1,59 @@
+"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 compiler_1 = require("./compiler");
+const config_1 = require("./config");
+const path = __importStar(require("path"));
+const moduleName = 'cspell-tools';
+const searchPlaces = [
+    `${moduleName}.config.json`,
+    `${moduleName}.config.yaml`,
+    `${moduleName}.config.yml`,
+    'package.json',
+];
+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, {
+        searchPlaces,
+        stopDir: path.resolve('.'),
+        transform: config_1.normalizeConfig,
+    });
+    const config = await (options.config ? explorer.load(options.config) : explorer.search('.'));
+    if (!config?.config) {
+        console.error('root: %s', options.root);
+        throw 'cspell-tools.config not found.';
+    }
+    await (0, compiler_1.compile)(config.config, { filter });
+}
+exports.build = build;
+//# sourceMappingURL=build.js.map

package/dist/compile.d.ts

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

package/dist/compile.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processCompileAction = void 0;
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const FeatureFlags_1 = require("./FeatureFlags");
+const compile_1 = require("./compiler/compile");
+const createCompileRequest_1 = require("./compiler/createCompileRequest");
+const globP_1 = require("./compiler/globP");
+(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);
+    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 sources = [
+        ...(0, sync_1.pipe)(globResults, (0, sync_1.opConcatMap)((a) => a)),
+    ];
+    return (0, compile_1.compile)((0, createCompileRequest_1.createCompileRequest)(sources, options));
+}
+//# sourceMappingURL=compile.js.map

package/dist/compiler/CompileOptions.d.ts

@@ -0,0 +1,12 @@
+export interface CompileOptions {
+    /**
+     * Sort the words in the resulting dictionary.
+     * Does not apply to `trie` based formats.
+     */
+    sort: boolean;
+    /**
+     * Generate lower case / accent free versions of words.
+     */
+    generateNonStrict: boolean;
+}
+//# sourceMappingURL=CompileOptions.d.ts.map

package/dist/compiler/CompileOptions.js

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

package/dist/compiler/Reader.d.ts

@@ -1,23 +1,28 @@
-import { Sequence } from 'gensequence';
 export interface ReaderOptions {
-    useAnnotation?: boolean;
+    /**
+     * Max Hunspell recursive depth.
+     */
     maxDepth?: number;
+    /**
+     * split words if necessary.
+     */
+    splitWords: boolean;
+    /**
+     * Indicate that it is an unformatted file and needs to be cleaned
+     * before processing. Applies only to text file sources.
+     * @default false
+     */
+    legacy?: boolean;
+    keepCase?: boolean;
 }
 export declare type AnnotatedWord = string;
 interface BaseReader {
     size: number;
-    annotatedWords: () => Sequence<AnnotatedWord>;
-    rawWords: () => Sequence<string>;
+    words: Iterable<AnnotatedWord>;
 }
-export interface Reader extends BaseReader {
-    [Symbol.iterator]: () => Sequence<string>;
+export interface Reader extends BaseReader, Iterable<string> {
 }
 export declare function createReader(filename: string, options: ReaderOptions): Promise<Reader>;
-export declare function createArrayReader(lines: string[]): BaseReader;
 export declare function readHunspellFiles(filename: string, options: ReaderOptions): Promise<BaseReader>;
-declare function _stripCaseAndAccents(words: Iterable<AnnotatedWord>): Generator<AnnotatedWord>;
-export declare const __testing__: {
-    _stripCaseAndAccents: typeof _stripCaseAndAccents;
-};
 export {};
 //# sourceMappingURL=Reader.d.ts.map