@zthun/janitor-lint 19.2.1 → 19.2.2

package/dist/janitor-lint-Caz9LdHb.js

@@ -0,0 +1,1358 @@
+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 asyncGeneratorStep$d(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$d(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$d(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$d(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ extend(config) {
+        return _async_to_generator$d(function*() {
+            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 = yield 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;
+        }).call(this);
+    }
+    /**
+   * Reads a module recursively.
+   *
+   * @param module
+   *        - The module to read.
+   *
+   * @returns
+   *        A promise that resolves the extended inner module.
+   */ _read(module) {
+        return _async_to_generator$d(function*() {
+            const data = $require(module);
+            return yield this.extend(data);
+        }).call(this);
+    }
+    /**
+   * 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 asyncGeneratorStep$c(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$c(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$c(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$c(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ search() {
+        return _async_to_generator$c(function*() {
+            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 = yield 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 = yield explorer.load(full).catch(()=>null);
+                if (result) {
+                    return result.filepath;
+                }
+            }
+            return null;
+        }).call(this);
+    }
+    /**
+   * 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.
+   */ read(config) {
+        return _async_to_generator$c(function*() {
+            const configLoad = config ? Promise.resolve(config) : this.search();
+            const configFile = yield configLoad;
+            if (!configFile) {
+                return {};
+            }
+            const path = $resolve(configFile, {
+                paths: [
+                    process.cwd()
+                ]
+            });
+            const buffer = yield cosmiconfig(this.name).load(path);
+            return yield this.extender.extend(buffer.config);
+        }).call(this);
+    }
+    /**
+   * 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;
+    }
+}
+
+function asyncGeneratorStep$b(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$b(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$b(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$b(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+/**
+ * Represents a config reader that returns the empty options.
+ */ class ZConfigReaderNull {
+    /**
+   * Returns a null resolved promise.
+   *
+   * @returns
+   *        A promise that resolves to null.
+   */ read() {
+        return _async_to_generator$b(function*() {
+            return null;
+        })();
+    }
+}
+
+function asyncGeneratorStep$a(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$a(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$a(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$a(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+/**
+ * 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.
+   */ read(config) {
+        return _async_to_generator$a(function*() {
+            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 = yield 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
+        });
+    }
+}
+
+function asyncGeneratorStep$9(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$9(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$9(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$9(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+/**
+ * Represents the linter for json files.
+ */ class ZContentLinterJson {
+    /**
+   * Lints the collection of json files.
+   *
+   * @param contents -
+   *        The json file contents.
+   */ lint(contents) {
+        return _async_to_generator$9(function*() {
+            return JSON.parse(contents);
+        })();
+    }
+}
+
+function asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$8(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+/**
+ * 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.
+   */ lint(content, contentPath, options) {
+        return _async_to_generator$8(function*() {
+            const file = yield getFileInfo(contentPath);
+            const finalOptions = Object.assign({}, {
+                parser: file.inferredParser
+            }, options);
+            const formatted = yield check(content, finalOptions);
+            if (!formatted) {
+                return Promise.reject(`${contentPath} is not formatted.`);
+            }
+            return Promise.resolve(`${contentPath} is properly formatted.`);
+        })();
+    }
+}
+
+function asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$7(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+/**
+ * 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.
+   */ lint(contents) {
+        return _async_to_generator$7(function*() {
+            return load(contents);
+        })();
+    }
+}
+
+function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$6(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(src, config) {
+        return _async_to_generator$6(function*() {
+            const esOptions = {
+                errorOnUnmatchedPattern: false
+            };
+            if (config) {
+                esOptions.overrideConfigFile = $resolve(config, {
+                    paths: [
+                        process.cwd()
+                    ]
+                });
+            }
+            try {
+                const engine = this.engineFactory(esOptions);
+                const formatter = yield engine.loadFormatter();
+                const report = yield 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;
+            }
+        }).call(this);
+    }
+    /**
+   * 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 asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(src, config, exclude) {
+        return _async_to_generator$5(function*() {
+            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 = yield 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 = yield readFileAsync(fullFilePath, "utf-8");
+                    yield this._contentLint.lint(content, fullFilePath, options, config);
+                } catch (err) {
+                    result = false;
+                    this._format(fullFilePath, err);
+                }
+            }
+            return result;
+        }).call(this);
+    }
+    /**
+   * 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 asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(_0, _1) {
+        return _async_to_generator$4(function*(src, cfg, exclude = []) {
+            let config;
+            try {
+                config = yield 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 = yield lint(options);
+            this._logger.log(`${result.toString().trim()}`);
+            return !some(values(result), (val)=>val.length > 0);
+        }).apply(this, arguments);
+    }
+    /**
+   * 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 asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(src, config, exclude) {
+        return _async_to_generator$3(function*() {
+            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);
+        }).call(this);
+    }
+    /**
+   * 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 asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(src, config, exclude) {
+        return _async_to_generator$2(function*() {
+            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 = yield lint$1(src, options, emitters);
+            if (runResult.errors > 0 || runResult.issues > 0) {
+                return false;
+            }
+            this._logger.log();
+            return true;
+        }).call(this);
+    }
+    /**
+   * 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 asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(content, config, exclude) {
+        return _async_to_generator$1(function*() {
+            const options = {
+                files: content,
+                ignorePattern: exclude
+            };
+            if (config) {
+                options.configFile = $resolve(config, {
+                    paths: [
+                        process.cwd()
+                    ]
+                });
+            }
+            const result = yield stylelint.lint(options);
+            const verbose = yield stylelint.formatters.verbose;
+            if (result.errored) {
+                const output = verbose(result.results, result);
+                this._logger.log(output);
+                return false;
+            }
+            this._logger.log("");
+            return true;
+        }).call(this);
+    }
+    /**
+   * 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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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.
+   */ lint(options) {
+        return _async_to_generator(function*() {
+            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 = yield 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 = yield 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 = yield 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 = yield 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 = yield 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 = yield this.htmlHint.lint(htmlFiles, htmlConfig, htmlFilesExclude);
+                result = result && current;
+            }
+            if (spellingFiles) {
+                this._logger.log(chalk.magenta.underline(`Checking spelling for ${spellingFiles.length} globs.`));
+                current = yield this.spellLint.lint(spellingFiles, spellingConfig, spellingFilesExclude);
+                result = result && current;
+            }
+            if (prettyFiles) {
+                this._logger.log(chalk.magenta.underline(`Checking formatting for ${prettyFiles.length} globs.`));
+                current = yield this.prettyLint.lint(prettyFiles, prettyConfig, prettyFilesExclude);
+                result = result && current;
+            }
+            return result ? 0 : 1;
+        }).call(this);
+    }
+    /**
+   * 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.
+   */ run(args) {
+        return _async_to_generator(function*() {
+            try {
+                const options = yield this.config.read(args.config);
+                return this.lint(options);
+            } catch (err) {
+                this._logger.error(err);
+                return 1;
+            }
+        }).call(this);
+    }
+    /**
+   * 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-Caz9LdHb.js.map