@zthun/janitor-lint 19.4.2 → 19.5.0

package/dist/janitor-lint-Dp9Vo0ze.cjs

@@ -0,0 +1,935 @@
+'use strict';
+
+const chalk = require('chalk');
+const node_module = require('node:module');
+const cosmiconfig = require('cosmiconfig');
+const path = require('path');
+const prettier = require('prettier');
+const htmlhint = require('htmlhint');
+const jsYaml = require('js-yaml');
+const eslint = require('eslint');
+const lodashEs = require('lodash-es');
+const fs = require('fs');
+const glob = require('glob');
+const util = require('util');
+const promise = require('markdownlint/promise');
+const cspell = require('cspell');
+const stylelint = require('stylelint');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function $require(id) {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('janitor-lint-Dp9Vo0ze.cjs', document.baseURI).href)));
+    return require$1(id);
+}
+function $resolve(id, options) {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('janitor-lint-Dp9Vo0ze.cjs', document.baseURI).href)));
+    return require$1.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.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$1 of this.paths){
+            const full = path.resolve(path$1);
+            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.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 prettier.resolveConfig(path.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.HTMLHint.verify(content, options);
+        if (messages.length > 0) {
+            const logs = htmlhint.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 prettier.getFileInfo(contentPath);
+        const finalOptions = Object.assign({}, {
+            parser: file.inferredParser
+        }, options);
+        const formatted = await prettier.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 jsYaml.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 lodashEs.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.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 = util.promisify(fs.readFile);
+        let options = {};
+        const globOptions = {
+            dot: true,
+            ignore: exclude
+        };
+        let files = [];
+        src.forEach((pattern)=>files = files.concat(glob.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 = path.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(glob.sync(pattern, globOptions)));
+        const options = {
+            files,
+            config
+        };
+        const result = await promise.lint(options);
+        this._logger.log(`${result.toString().trim()}`);
+        return !lodashEs.some(lodashEs.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(glob.sync(pattern, globOptions)));
+        files = lodashEs.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 = lodashEs.noop;
+        const debug = lodashEs.noop;
+        const error = lodashEs.noop;
+        const progress = lodashEs.noop;
+        const result = lodashEs.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 cspell.lint(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());
+    }
+}
+
+exports.ZConfigExtender = ZConfigExtender;
+exports.ZConfigReaderCosmic = ZConfigReaderCosmic;
+exports.ZConfigReaderNull = ZConfigReaderNull;
+exports.ZConfigReaderPrettier = ZConfigReaderPrettier;
+exports.ZContentLinterHtml = ZContentLinterHtml;
+exports.ZContentLinterJson = ZContentLinterJson;
+exports.ZContentLinterPretty = ZContentLinterPretty;
+exports.ZContentLinterYaml = ZContentLinterYaml;
+exports.ZJanitorLint = ZJanitorLint;
+exports.ZLinterEs = ZLinterEs;
+exports.ZLinterFile = ZLinterFile;
+exports.ZLinterMarkdown = ZLinterMarkdown;
+exports.ZLinterReport = ZLinterReport;
+exports.ZLinterSpelling = ZLinterSpelling;
+exports.ZLinterStyle = ZLinterStyle;
+//# sourceMappingURL=janitor-lint-Dp9Vo0ze.cjs.map