@zthun/janitor-lint 19.4.3 → 19.5.0

package/dist/janitor-lint-DdyMWYZn.js

@@ -0,0 +1,918 @@
+import chalk from 'chalk';
+import { createRequire } from 'node:module';
+import { cosmiconfig } from 'cosmiconfig';
+import { resolve } from 'path';
+import { resolveConfig, getFileInfo, check } from 'prettier';
+import { HTMLHint } from 'htmlhint';
+import { load } from 'js-yaml';
+import { ESLint } from 'eslint';
+import { every, some, values, uniq, noop } from 'lodash-es';
+import { readFile } from 'fs';
+import { sync } from 'glob';
+import { promisify } from 'util';
+import { lint } from 'markdownlint/promise';
+import { lint as lint$1 } from 'cspell';
+import stylelint from 'stylelint';
+
+function $require(id) {
+    const require = createRequire(import.meta.url);
+    return require(id);
+}
+function $resolve(id, options) {
+    const require = createRequire(import.meta.url);
+    return require.resolve(id, options);
+}
+
+function _define_property$9(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents the standard extender.
+ *
+ * This extender works the same as how eslint extends their
+ * configuration.  You can pass a key that acts as the extends key which holds paths
+ * to the extendable files/modules. Note that this class, unlike eslint, does not assume any naming
+ * conventions and ONLY shared configurations are supported.  You must pass the full path of the
+ * configs when extending, and plugin based syntax is not recognized.
+ *
+ * It is always better to just use the extension methods of the actual
+ * applications if those are available, but this can be used as a fallback or an
+ * extension of behavior for child linters that do not support extendable configs.
+ */ class ZConfigExtender {
+    /**
+   * Extends the configuration value.
+   *
+   * This is similar to how eslint works.  This will do an
+   * asynchronous require on each configuration under the key in the
+   * config.  If the key in the config is falsy, then the config is returned.
+   *
+   * The actual key in the config is deleted.
+   *
+   * @param config
+   *        - The config to extend.
+   *
+   * @returns
+   *        A promise that resolves the extended configuration.
+   */ async extend(config) {
+        if (config == null || !Object.hasOwnProperty.call(config, this.key)) {
+            return config;
+        }
+        const extensions = config[this.key];
+        const modules = Array.isArray(extensions) ? extensions : [
+            extensions
+        ];
+        const resolved = await Promise.all(modules.map((m)=>this._read(m)));
+        let updated = resolved.reduce((last, current)=>Object.assign({}, last, current), {});
+        updated = Object.assign({}, updated, config);
+        delete updated[this.key];
+        return updated;
+    }
+    /**
+   * Reads a module recursively.
+   *
+   * @param module
+   *        - The module to read.
+   *
+   * @returns
+   *        A promise that resolves the extended inner module.
+   */ async _read(module) {
+        const data = $require(module);
+        return await this.extend(data);
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param key
+   *        - The key to extend.
+   */ constructor(key = "extends"){
+        _define_property$9(this, "key", void 0);
+        this.key = key;
+    }
+}
+
+function _define_property$8(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents a reader that uses the cosmiconfig standard for files.
+ */ class ZConfigReaderCosmic {
+    /**
+   * Runs a search for the appropriate configuration file.
+   *
+   * The extension keyword is deleted from the config.
+   *
+   * @returns
+   *        A promise that resolves with the expanded configuration.
+   */ async search() {
+        const explorer = cosmiconfig(this.name, {
+            searchStrategy: "project"
+        });
+        // The first step is the standard cosmiconfig
+        // search to see if any of these paths exists.
+        // These are highest priority.
+        const searched = await explorer.search();
+        if (searched) {
+            return searched.filepath;
+        }
+        // Try our additional paths, if any.
+        for (const path of this.paths){
+            const full = resolve(path);
+            const result = await explorer.load(full).catch(()=>null);
+            if (result) {
+                return result.filepath;
+            }
+        }
+        return null;
+    }
+    /**
+   * Reads the config file.
+   *
+   * @param config -
+   *        The optional configuration file.  If this is null then the cosmiconfig path is searched on the name.
+   *
+   * @returns
+   *        A promise that resolves the json object that represents the config.
+   */ async read(config) {
+        const configLoad = config ? Promise.resolve(config) : this.search();
+        const configFile = await configLoad;
+        if (!configFile) {
+            return {};
+        }
+        const path = $resolve(configFile, {
+            paths: [
+                process.cwd()
+            ]
+        });
+        const buffer = await cosmiconfig(this.name).load(path);
+        return await this.extender.extend(buffer.config);
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param name -
+   *        The name of the application to load.
+   * @param extender -
+   *        The extender to expand upon the read configuration.
+   * @param paths -
+   *        The additional paths to read if cosmic config does not find a valid config.  Remember that these
+   *        are paths, not modules in this case, so you can't load things from the node modules directory
+   *        using these values.  These only affect the search for the config file, not the actual
+   *        read of the config.
+   */ constructor(name, extender, paths = []){
+        _define_property$8(this, "name", void 0);
+        _define_property$8(this, "extender", void 0);
+        _define_property$8(this, "paths", void 0);
+        this.name = name;
+        this.extender = extender;
+        this.paths = paths;
+    }
+}
+
+/**
+ * Represents a config reader that returns the empty options.
+ */ class ZConfigReaderNull {
+    /**
+   * Returns a null resolved promise.
+   *
+   * @returns
+   *        A promise that resolves to null.
+   */ async read() {
+        return null;
+    }
+}
+
+/**
+ * Represents a configuration reader for prettier.
+ */ class ZConfigReaderPrettier {
+    /**
+   * Reads the configuration file.
+   *
+   * @param config -
+   *        The config module to load.  If this value is falsy,
+   *        then prettier will be used to retrieve the configuration.
+   *
+   * @returns
+   *        The options for the config file.
+   */ async read(config) {
+        const cwd = process.cwd();
+        const configFile = config ? $resolve(config, {
+            paths: [
+                cwd
+            ]
+        }) : undefined;
+        const ops = {
+            config: configFile
+        };
+        // This function seems to have a slight issue in that it needs one directory deeper than
+        // the directory you want to start the search in.  The documentation on this isn't exactly correct,
+        // and it was this change, https://github.com/prettier/prettier/pull/15363/files#diff-6569a6bfe16237da3c47f035a6f3325a79e958507cf866a1bd703ae9210129b3,
+        // that broke it.
+        const options = await resolveConfig(resolve(process.cwd(), "some-prettier-config"), ops);
+        return options || {};
+    }
+}
+
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents an object that can be used to hint html files.
+ */ class ZContentLinterHtml {
+    /**
+   * Lints the content.
+   *
+   * @param content -
+   *        The content to check.
+   * @param contentPath -
+   *        The path of the content data.
+   * @param options -
+   *        The htmlhint options.
+   *
+   * @returns
+   *        A promise that resolves if the content is lint free, and rejects if it has lint errors.
+   */ lint(content, contentPath, options) {
+        const messages = HTMLHint.verify(content, options);
+        if (messages.length > 0) {
+            const logs = HTMLHint.format(messages, this._formatOptions);
+            return Promise.reject(logs);
+        }
+        return Promise.resolve(`${contentPath} is lint free.`);
+    }
+    constructor(){
+        _define_property$7(this, "_formatOptions", {
+            colors: true
+        });
+    }
+}
+
+/**
+ * Represents the linter for json files.
+ */ class ZContentLinterJson {
+    /**
+   * Lints the collection of json files.
+   *
+   * @param contents -
+   *        The json file contents.
+   */ async lint(contents) {
+        return JSON.parse(contents);
+    }
+}
+
+/**
+ * Represents an object that can be used to perform prettier checks on files.
+ */ class ZContentLinterPretty {
+    /**
+   * Lints the content.
+   *
+   * @param content -
+   *        The content to check.
+   * @param contentPath -
+   *        The path of the content data.
+   * @param options -
+   *        The htmlhint options.
+   *
+   * @returns
+   *        A promise that resolves if the content is lint free, and rejects if it has lint errors.
+   */ async lint(content, contentPath, options) {
+        const file = await getFileInfo(contentPath);
+        const finalOptions = Object.assign({}, {
+            parser: file.inferredParser
+        }, options);
+        const formatted = await check(content, finalOptions);
+        if (!formatted) {
+            return Promise.reject(`${contentPath} is not formatted.`);
+        }
+        return Promise.resolve(`${contentPath} is properly formatted.`);
+    }
+}
+
+/**
+ * Represents a linter for yml files.
+ */ class ZContentLinterYaml {
+    /**
+   * Lints yml files.
+   *
+   * @param contents -
+   *        Yaml formatted string.
+   *
+   * @returns
+   *        A promise that resolves if successful, or rejects if failed.
+   */ async lint(contents) {
+        return load(contents);
+    }
+}
+
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents an object that can be used to perform eslint on javascript files.
+ */ class ZLinterEs {
+    /**
+   * Runs the lint given the specified config and source files.
+   *
+   * @param src -
+   *        The list of files globs to lint.
+   * @param config -
+   *        The optional lint config file.
+   *
+   * @returns
+   *        A promise that resolves to true if the lint is
+   *        fully successful, and false if the lint
+   *        has errors.
+   */ async lint(src, config) {
+        const esOptions = {
+            errorOnUnmatchedPattern: false
+        };
+        if (config) {
+            esOptions.overrideConfigFile = $resolve(config, {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        }
+        try {
+            const engine = this.engineFactory(esOptions);
+            const formatter = await engine.loadFormatter();
+            const report = await engine.lintFiles(src);
+            const output = formatter.format(report);
+            this._logger.log(output);
+            return every(report, (r)=>r.errorCount === 0);
+        } catch (err) {
+            this._logger.log(err);
+            return false;
+        }
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _logger -
+   *        The logger to output to.
+   */ constructor(_logger){
+        _define_property$6(this, "_logger", void 0);
+        /**
+   * The factory that constructs a CLIEngine object.
+   *
+   * @param options -
+   *        The engine options.
+   *
+   * @returns
+   *        The engine that can be used to perform eslint.
+   */ _define_property$6(this, "engineFactory", void 0);
+        this._logger = _logger;
+        this.engineFactory = (options)=>new ESLint(options);
+    }
+}
+
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents an object that can lint files one at a time.
+ */ class ZLinterFile {
+    /**
+   * Lints the collection of json files.
+   *
+   * @param src -
+   *        The file list of blobs to lint.
+   * @param config -
+   *        The optional path to the config file.
+   * @param exclude -
+   *        The list of globs to exclude.
+   */ async lint(src, config, exclude) {
+        const readFileAsync = promisify(readFile);
+        let options = {};
+        const globOptions = {
+            dot: true,
+            ignore: exclude
+        };
+        let files = [];
+        src.forEach((pattern)=>files = files.concat(sync(pattern, globOptions)));
+        if (files.length === 0) {
+            this._logger.log(chalk.yellow.italic("No globs matched any files."));
+            return true;
+        }
+        try {
+            options = await this._configReader.read(config);
+        } catch (err) {
+            this._logger.error(chalk.red(err));
+            return false;
+        }
+        this._logger.log(chalk.green.italic(`Checking syntax for ${files.length} ${this._type} files.`));
+        this._logger.log();
+        let result = true;
+        for (const file of files){
+            const fullFilePath = resolve(file);
+            try {
+                const content = await readFileAsync(fullFilePath, "utf-8");
+                await this._contentLint.lint(content, fullFilePath, options, config);
+            } catch (err) {
+                result = false;
+                this._format(fullFilePath, err);
+            }
+        }
+        return result;
+    }
+    /**
+   * Formats a file error to the logger.
+   *
+   * @param file -
+   *        The file that failed to parse.
+   * @param err -
+   *        The error that occurred.Ø
+   */ _format(file, err) {
+        const fileFormat = `Errors in ${file}`;
+        this._logger.error(chalk.green.underline(fileFormat));
+        if (Array.isArray(err)) {
+            err.forEach((log)=>this._logger.error(chalk.red(log)));
+        } else {
+            this._logger.error(chalk.red(err));
+        }
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _contentLint -
+   *        The linter for an individual file.
+   * @param _configReader -
+   *        The config reader.
+   * @param _logger -
+   *        The logger to use.
+   * @param _type -
+   *        The file type.
+   */ constructor(_contentLint, _configReader, _logger, _type){
+        _define_property$5(this, "_contentLint", void 0);
+        _define_property$5(this, "_configReader", void 0);
+        _define_property$5(this, "_logger", void 0);
+        _define_property$5(this, "_type", void 0);
+        this._contentLint = _contentLint;
+        this._configReader = _configReader;
+        this._logger = _logger;
+        this._type = _type;
+    }
+}
+
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents a linter object that checks markdown.
+ */ class ZLinterMarkdown {
+    /**
+   * Lints all files matched by the specified glob pattern.
+   *
+   * @param src -
+   *        The glob patterns to match and lint.
+   * @param cfg -
+   *        The optional config for the linter.
+   * @param exclude -
+   *        The glob patterns to exclude.
+   *
+   * @returns A promise that resolves to true if the linting is ok, and false if the linting fails.
+   */ async lint(src, cfg, exclude = []) {
+        let config;
+        try {
+            config = await this._reader.read(cfg);
+        } catch (err) {
+            this._logger.error(chalk.red(err));
+            return false;
+        }
+        const globOptions = {
+            dot: true,
+            ignore: exclude
+        };
+        let files = [];
+        src.forEach((pattern)=>files = files.concat(sync(pattern, globOptions)));
+        const options = {
+            files,
+            config
+        };
+        const result = await lint(options);
+        this._logger.log(`${result.toString().trim()}`);
+        return !some(values(result), (val)=>val.length > 0);
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _logger -
+   *        The logger to write messages to.
+   * @param _reader -
+   *        The configuration reader.
+   */ constructor(_logger, _reader){
+        _define_property$4(this, "_logger", void 0);
+        _define_property$4(this, "_reader", void 0);
+        this._logger = _logger;
+        this._reader = _reader;
+    }
+}
+
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents an object that will report on file globs, but will
+ * pass the actual linting job to another linter.
+ */ class ZLinterReport {
+    /**
+   * Lints the collection of json files.
+   *
+   * @param src -
+   *        The file list of blobs to lint.
+   * @param config -
+   *        The optional path to the config file.
+   * @param exclude -
+   *        The list of globs to exclude.
+   */ async lint(src, config, exclude) {
+        const globOptions = {
+            dot: true,
+            ignore: exclude
+        };
+        let files = [];
+        src.forEach((pattern)=>files = files.concat(sync(pattern, globOptions)));
+        files = uniq(files);
+        if (files.length === 0) {
+            this._logger.log(chalk.yellow.italic("No globs matched any files."));
+            return true;
+        }
+        this._logger.log(chalk.green.italic(`Checking syntax for ${files.length} ${this._type} files.`));
+        return this._child.lint(src, config, exclude);
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _child -
+   *        The child linter to pass the operation off to.
+   * @param _logger -
+   *        The logger to use.
+   * @param _type -
+   *        The file type.
+   */ constructor(_child, _logger, _type){
+        _define_property$3(this, "_child", void 0);
+        _define_property$3(this, "_logger", void 0);
+        _define_property$3(this, "_type", void 0);
+        this._child = _child;
+        this._logger = _logger;
+        this._type = _type;
+    }
+}
+
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents an object that can be used to perform cspell on files.
+ */ class ZLinterSpelling {
+    /**
+   * Runs the lint given the specified config and source files.
+   *
+   * @param src -
+   *        The list of files globs to lint.
+   * @param config -
+   *        The optional lint config file.
+   * @param exclude -
+   *        The list of file globs to exclude.
+   *
+   * @returns
+   *        A promise that resolves to true if the
+   *        lint is fully successful, and false if the lint
+   *        has errors.
+   */ async lint(src, config, exclude) {
+        const options = {
+            exclude
+        };
+        if (config) {
+            options.config = $resolve(config, {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        }
+        const info = noop;
+        const debug = noop;
+        const error = noop;
+        const progress = noop;
+        const result = noop;
+        const issue = (issue)=>{
+            const position = `${issue.row}:${issue.col}`;
+            this._logger.log(`${chalk.green(issue.uri)}:${chalk.yellow(position)} - Unknown word (${chalk.red(issue.text)})`);
+        };
+        const emitters = {
+            info,
+            debug,
+            error,
+            progress,
+            issue,
+            result
+        };
+        const runResult = await lint$1(src, options, emitters);
+        if (runResult.errors > 0 || runResult.issues > 0) {
+            return false;
+        }
+        this._logger.log();
+        return true;
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _logger -
+   *        The logger to output to.
+   */ constructor(_logger){
+        _define_property$2(this, "_logger", void 0);
+        this._logger = _logger;
+    }
+}
+
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents a linter for stylelint.
+ */ class ZLinterStyle {
+    /**
+   * Runs the file globs through the stylelint application.
+   *
+   * @param content -
+   *        The list of globs to lint.
+   * @param config -
+   *        The linter config file.
+   * @param exclude
+   *        The globs to exclude.
+   *
+   * @returns
+   *        A promise that, when resolved, returns true
+   *        if there are no lint errors, or
+   *        false if errors are present.
+   */ async lint(content, config, exclude) {
+        const options = {
+            files: content,
+            ignorePattern: exclude
+        };
+        if (config) {
+            options.configFile = $resolve(config, {
+                paths: [
+                    process.cwd()
+                ]
+            });
+        }
+        const result = await stylelint.lint(options);
+        const verbose = await stylelint.formatters.verbose;
+        if (result.errored) {
+            const output = verbose(result.results, result);
+            this._logger.log(output);
+            return false;
+        }
+        this._logger.log("");
+        return true;
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _logger -
+   *        The logger to log the output to.
+   */ constructor(_logger){
+        _define_property$1(this, "_logger", void 0);
+        this._logger = _logger;
+    }
+}
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Represents the main entry point object for the application.
+ */ class ZJanitorLint {
+    /**
+   * Runs the lint given the required options.
+   *
+   * @param options -
+   *        The lint options.
+   *
+   * @returns
+   *        A promise that returns 0 if all linting was successful,
+   *        and 1 if any of the linting failed.
+   */ async lint(options) {
+        let current = true;
+        let result = true;
+        const { lint = {} } = options;
+        const { jsonFiles, jsonFilesExclude, yamlFiles, yamlFilesExclude, markdownConfig, markdownFiles, markdownFilesExclude, esConfig, esFiles, styleConfig, styleFiles, styleFilesExclude, htmlConfig, htmlFiles, htmlFilesExclude, spellingConfig, spellingFiles, spellingFilesExclude, prettyConfig, prettyFiles, prettyFilesExclude } = lint;
+        if (jsonFiles) {
+            this._logger.log(chalk.magenta.underline(`Linting json files from ${jsonFiles.length} globs.`));
+            current = await this.jsonLint.lint(jsonFiles, undefined, jsonFilesExclude);
+            result = result && current;
+        }
+        if (yamlFiles) {
+            this._logger.log(chalk.magenta.underline(`Linting yaml files from ${yamlFiles.length} globs.`));
+            current = await this.yamlLint.lint(yamlFiles, undefined, yamlFilesExclude);
+            result = result && current;
+        }
+        if (markdownFiles) {
+            this._logger.log(chalk.magenta.underline(`Linting markdown files from ${markdownFiles.length} globs.`));
+            current = await this.markdownLint.lint(markdownFiles, markdownConfig, markdownFilesExclude);
+            result = result && current;
+        }
+        if (esFiles) {
+            this._logger.log(chalk.magenta.underline(`Linting ecmaScript files from ${esFiles.length} globs.`));
+            current = await this.esLint.lint(esFiles, esConfig, undefined);
+            result = result && current;
+        }
+        if (styleFiles) {
+            this._logger.log(chalk.magenta.underline(`Linting style files from ${styleFiles.length} globs.`));
+            current = await this.styleLint.lint(styleFiles, styleConfig, styleFilesExclude);
+            result = result && current;
+        }
+        if (htmlFiles) {
+            this._logger.log(chalk.magenta.underline(`Linting html files from ${htmlFiles.length} globs.`));
+            current = await this.htmlHint.lint(htmlFiles, htmlConfig, htmlFilesExclude);
+            result = result && current;
+        }
+        if (spellingFiles) {
+            this._logger.log(chalk.magenta.underline(`Checking spelling for ${spellingFiles.length} globs.`));
+            current = await this.spellLint.lint(spellingFiles, spellingConfig, spellingFilesExclude);
+            result = result && current;
+        }
+        if (prettyFiles) {
+            this._logger.log(chalk.magenta.underline(`Checking formatting for ${prettyFiles.length} globs.`));
+            current = await this.prettyLint.lint(prettyFiles, prettyConfig, prettyFilesExclude);
+            result = result && current;
+        }
+        return result ? 0 : 1;
+    }
+    /**
+   * Runs the application.
+   *
+   * @param args -
+   *        The command line arguments.
+   *
+   * @returns
+   *        A promise that returns 0 if all linting was
+   *        successful, and 1 if any of the linting failed.
+   */ async run(args) {
+        try {
+            const options = await this.config.read(args.config);
+            return this.lint(options);
+        } catch (err) {
+            this._logger.error(err);
+            return 1;
+        }
+    }
+    /**
+   * Initializes a new instance of this object.
+   *
+   * @param _logger -
+   *        The logger to use when formatting output.
+   */ constructor(_logger){
+        _define_property(this, "_logger", void 0);
+        /**
+   * The linter for js files.
+   */ _define_property(this, "esLint", void 0);
+        /**
+   * The linter for cspell.  Useful for multiple file types.
+   */ _define_property(this, "spellLint", void 0);
+        /**
+   * The linter for prettier formatting checks.
+   */ _define_property(this, "prettyLint", void 0);
+        /**
+   * The linter for style files.
+   */ _define_property(this, "styleLint", void 0);
+        /**
+   * The linter for html files.
+   *
+   * Currently, htmlhint has no support for cosmiconfig based paths, so we're going to
+   * add them here.
+   */ _define_property(this, "htmlHint", void 0);
+        /**
+   * The linter for json files.
+   */ _define_property(this, "jsonLint", void 0);
+        /**
+   * The linter for yaml files.
+   */ _define_property(this, "yamlLint", void 0);
+        /**
+   * The linter for markdown files.
+   *
+   * Markdownlint is a bit annoying with this.  They
+   * don't really fully support the cosmiconfig standard,
+   * and they only support the config files that are named
+   * .markdownlint.yaml, .markdownlint.json, and .markdownlint.cjs
+   */ _define_property(this, "markdownLint", void 0);
+        /**
+   * The configuration reader.
+   */ _define_property(this, "config", void 0);
+        this._logger = _logger;
+        this.esLint = new ZLinterReport(new ZLinterEs(this._logger), this._logger, "es");
+        this.spellLint = new ZLinterReport(new ZLinterSpelling(this._logger), this._logger, "various");
+        this.prettyLint = new ZLinterFile(new ZContentLinterPretty(), new ZConfigReaderPrettier(), this._logger, "pretty");
+        this.styleLint = new ZLinterReport(new ZLinterStyle(this._logger), this._logger, "style");
+        this.htmlHint = new ZLinterFile(new ZContentLinterHtml(), new ZConfigReaderCosmic("htmlhint", new ZConfigExtender()), this._logger, "html");
+        this.jsonLint = new ZLinterFile(new ZContentLinterJson(), new ZConfigReaderNull(), this._logger, "json");
+        this.yamlLint = new ZLinterFile(new ZContentLinterYaml(), new ZConfigReaderNull(), this._logger, "yaml");
+        this.markdownLint = new ZLinterReport(new ZLinterMarkdown(this._logger, new ZConfigReaderCosmic("markdownlint", new ZConfigExtender(), [
+            ".markdownlint.json",
+            ".markdownlint.yaml",
+            ".markdownlint.cjs"
+        ])), this._logger, "markdown");
+        this.config = new ZConfigReaderCosmic("janitor", new ZConfigExtender());
+    }
+}
+
+export { ZJanitorLint as Z, ZConfigExtender as a, ZConfigReaderCosmic as b, ZConfigReaderNull as c, ZConfigReaderPrettier as d, ZContentLinterHtml as e, ZContentLinterJson as f, ZContentLinterPretty as g, ZContentLinterYaml as h, ZLinterEs as i, ZLinterFile as j, ZLinterMarkdown as k, ZLinterReport as l, ZLinterSpelling as m, ZLinterStyle as n };
+//# sourceMappingURL=janitor-lint-DdyMWYZn.js.map