@zthun/janitor-lint 19.2.1 → 19.2.2

package/dist/janitor-lint-qkTWaEzl.js

@@ -1,819 +0,0 @@
-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 require2 = createRequire(import.meta.url);
-  return require2(id);
-}
-function $resolve(id, options) {
-  const require2 = createRequire(import.meta.url);
-  return require2.resolve(id, options);
-}
-class ZConfigExtender {
-  /**
-   * Initializes a new instance of this object.
-   *
-   * @param key
-   *        - The key to extend.
-   */
-  constructor(key = "extends") {
-    this.key = key;
-  }
-  /**
-   * 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);
-  }
-}
-class ZConfigReaderCosmic {
-  /**
-   * 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 = []) {
-    this.name = name;
-    this.extender = extender;
-    this.paths = paths;
-  }
-  /**
-   * 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" });
-    const searched = await explorer.search();
-    if (searched) {
-      return searched.filepath;
-    }
-    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);
-  }
-}
-class ZConfigReaderNull {
-  /**
-   * Returns a null resolved promise.
-   *
-   * @returns
-   *        A promise that resolves to null.
-   */
-  async read() {
-    return null;
-  }
-}
-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] }) : void 0;
-    const ops = { config: configFile };
-    const options = await resolveConfig(
-      resolve(process.cwd(), "some-prettier-config"),
-      ops
-    );
-    return options || {};
-  }
-}
-class ZContentLinterHtml {
-  constructor() {
-    this._formatOptions = { colors: true };
-  }
-  /**
-   * 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.`);
-  }
-}
-class ZContentLinterJson {
-  /**
-   * Lints the collection of json files.
-   *
-   * @param contents -
-   *        The json file contents.
-   */
-  async lint(contents) {
-    return JSON.parse(contents);
-  }
-}
-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.`);
-  }
-}
-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);
-  }
-}
-class ZLinterEs {
-  /**
-   * Initializes a new instance of this object.
-   *
-   * @param _logger -
-   *        The logger to output to.
-   */
-  constructor(_logger) {
-    this._logger = _logger;
-    this.engineFactory = (options) => new ESLint(options);
-  }
-  /**
-   * 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;
-    }
-  }
-}
-class ZLinterFile {
-  /**
-   * 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) {
-    this._contentLint = _contentLint;
-    this._configReader = _configReader;
-    this._logger = _logger;
-    this._type = _type;
-  }
-  /**
-   * 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));
-    }
-  }
-}
-class ZLinterMarkdown {
-  /**
-   * Initializes a new instance of this object.
-   *
-   * @param _logger -
-   *        The logger to write messages to.
-   * @param _reader -
-   *        The configuration reader.
-   */
-  constructor(_logger, _reader) {
-    this._logger = _logger;
-    this._reader = _reader;
-  }
-  /**
-   * 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);
-  }
-}
-class ZLinterReport {
-  /**
-   * 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) {
-    this._child = _child;
-    this._logger = _logger;
-    this._type = _type;
-  }
-  /**
-   * 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);
-  }
-}
-class ZLinterSpelling {
-  /**
-   * Initializes a new instance of this object.
-   *
-   * @param _logger -
-   *        The logger to output to.
-   */
-  constructor(_logger) {
-    this._logger = _logger;
-  }
-  /**
-   * 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 = (issue2) => {
-      const position = `${issue2.row}:${issue2.col}`;
-      this._logger.log(
-        `${chalk.green(issue2.uri)}:${chalk.yellow(position)} - Unknown word (${chalk.red(issue2.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;
-  }
-}
-class ZLinterStyle {
-  /**
-   * Initializes a new instance of this object.
-   *
-   * @param _logger -
-   *        The logger to log the output to.
-   */
-  constructor(_logger) {
-    this._logger = _logger;
-  }
-  /**
-   * 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;
-  }
-}
-class ZJanitorLint {
-  /**
-   * Initializes a new instance of this object.
-   *
-   * @param _logger -
-   *        The logger to use when formatting output.
-   */
-  constructor(_logger) {
-    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());
-  }
-  /**
-   * 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: lint2 = {} } = options;
-    const {
-      jsonFiles,
-      jsonFilesExclude,
-      yamlFiles,
-      yamlFilesExclude,
-      markdownConfig,
-      markdownFiles,
-      markdownFilesExclude,
-      esConfig,
-      esFiles,
-      styleConfig,
-      styleFiles,
-      styleFilesExclude,
-      htmlConfig,
-      htmlFiles,
-      htmlFilesExclude,
-      spellingConfig,
-      spellingFiles,
-      spellingFilesExclude,
-      prettyConfig,
-      prettyFiles,
-      prettyFilesExclude
-    } = lint2;
-    if (jsonFiles) {
-      this._logger.log(
-        chalk.magenta.underline(
-          `Linting json files from ${jsonFiles.length} globs.`
-        )
-      );
-      current = await this.jsonLint.lint(
-        jsonFiles,
-        void 0,
-        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,
-        void 0,
-        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, void 0);
-      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;
-    }
-  }
-}
-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-qkTWaEzl.js.map