@storm-software/linting-tools 1.15.9 → 1.15.11

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [1.15.10](https://github.com/storm-software/storm-ops/compare/linting-tools-v1.15.9...linting-tools-v1.15.10) (2023-12-06)
+
+
+### Bug Fixes
+
+* **workspace-tools:** Resolved issue with bad options passed into base TS library generator ([aeff286](https://github.com/storm-software/storm-ops/commit/aeff286fba411b47c205f3d13cefb425b2c1a977))
+
+## [1.15.9](https://github.com/storm-software/storm-ops/compare/linting-tools-v1.15.8...linting-tools-v1.15.9) (2023-12-05)
+
+
+### Bug Fixes
+
+* **git-tools:** Resolved issue in `semantic-release` patch with module directory ([a04aa3a](https://github.com/storm-software/storm-ops/commit/a04aa3add212abc781392d1227122a790b2f004e))
+* **git-tools:** Resolved issue with patched semantic-release bundled path ([93b4e43](https://github.com/storm-software/storm-ops/commit/93b4e439bf19a888db1b35554b32b9aec3cc3acd))
+* **git-tools:** Update the env used by packages to match new config updates ([d3b7dac](https://github.com/storm-software/storm-ops/commit/d3b7dac057a04aff9e0170d89cedc4cb47c584e5))
+* **git-tools:** Updated `semantic-release` patch to properly check for plugins ([4e3db96](https://github.com/storm-software/storm-ops/commit/4e3db96814e8abb5cb22d9bfb5c747f042c43157))
+
 ## [1.15.8](https://github.com/storm-software/storm-ops/compare/linting-tools-v1.15.7...linting-tools-v1.15.8) (2023-12-05)
 
 

package/README.md

@@ -16,7 +16,7 @@ This package is part of the <b>⚡Storm-Ops</b> monorepo. The Storm-Ops packages
 
 <h3 align="center">💻 Visit <a href="https://stormsoftware.org" target="_blank">stormsoftware.org</a> to stay up to date with this developer</h3><br />
 
-[![Version](https://img.shields.io/badge/version-1.15.7-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;
+[![Version](https://img.shields.io/badge/version-1.15.10-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;
 [![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with docusaurus](https://img.shields.io/badge/documented_with-docusaurus-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://docusaurus.io/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/storm-ops/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
 
 <h3 align="center" bold="true">⚠️ <b>Attention</b> ⚠️ This repository, and the apps, libraries, and tools contained within, is still in it's initial development phase. As a result, bugs and issues are expected with it's usage. When the main development phase completes, a proper release will be performed, the packages will be availible through NPM (and other distributions), and this message will be removed. However, in the meantime, please feel free to report any issues you may come across.</h3><br />

package/cli/index.js

@@ -251727,6 +251727,379 @@ var require_dir_glob = __commonJS({
   }
 });
 
+// node_modules/.pnpm/ignore@5.3.0/node_modules/ignore/index.js
+var require_ignore3 = __commonJS({
+  "node_modules/.pnpm/ignore@5.3.0/node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var EMPTY2 = "";
+    var SPACE = " ";
+    var ESCAPE2 = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define2 = (object, key, value) => Object.defineProperty(object, key, { value });
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match3, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match3 : EMPTY2
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a \ ) -> (a  )
+        /\\?\s+$/,
+        (match3) => match3.indexOf("\\") === 0 ? SPACE : EMPTY2
+      ],
+      // replace (\ ) with ' '
+      [
+        /\\\s/g,
+        () => SPACE
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match3) => `\\${match3}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index2, str2) => index2 + 6 < str2.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE2
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE2
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match3, leadEscape, range, endEscape, close) => leadEscape === ESCAPE2 ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match3) => /\/$/.test(match3) ? `${match3}$` : `${match3}(?=$|\\/$)`
+      ],
+      // trailing wildcard
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = (pattern, ignoreCase2) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase2 ? new RegExp(source, "i") : new RegExp(source);
+    };
+    var isString3 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString3(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+    var IgnoreRule = class {
+      constructor(origin, pattern, negative, regex2) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex2;
+      }
+    };
+    var createRule = (pattern, ignoreCase2) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex2 = makeRegex(pattern, ignoreCase2);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex2
+      );
+    };
+    var throwError2 = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path38, originalPath, doThrow) => {
+      if (!isString3(path38)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path38) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path38)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path38) => REGEX_TEST_INVALID_PATH.test(path38);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore3 = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase: ignoreCase2 = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define2(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase2;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString3(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      //          |           ignored : unignored
+      // negative |   0:0   |   0:1   |   1:0   |   1:1
+      // -------- | ------- | ------- | ------- | --------
+      //     0    |  TEST   |  TEST   |  SKIP   |    X
+      //     1    |  TESTIF |  SKIP   |  TEST   |    X
+      // - SKIP: always skip
+      // - TEST: always test
+      // - TESTIF: only test if checkUnignored
+      // - X: that never happen
+      // @param {boolean} whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // @returns {TestResult} true if a file is ignored
+      _testOne(path38, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path38);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache3, checkUnignored, slices) {
+        const path38 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path38,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError2
+        );
+        return this._t(path38, cache3, checkUnignored, slices);
+      }
+      _t(path38, cache3, checkUnignored, slices) {
+        if (path38 in cache3) {
+          return cache3[path38];
+        }
+        if (!slices) {
+          slices = path38.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache3[path38] = this._testOne(path38, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache3,
+          checkUnignored,
+          slices
+        );
+        return cache3[path38] = parent.ignored ? parent : this._testOne(path38, checkUnignored);
+      }
+      ignores(path38) {
+        return this._test(path38, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path38) => !this.ignores(path38);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path38) {
+        return this._test(path38, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore3(options);
+    var isPathValid = (path38) => checkPath(path38 && checkPath.convert(path38), path38, RETURN_FALSE);
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module.exports = factory;
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+    ) {
+      const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path38) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path38) || isNotRelative(path38);
+    }
+  }
+});
+
 // node_modules/.pnpm/slash@3.0.0/node_modules/slash/index.js
 var require_slash = __commonJS({
   "node_modules/.pnpm/slash@3.0.0/node_modules/slash/index.js"(exports, module) {
@@ -251750,7 +252123,7 @@ var require_gitignore = __commonJS({
     var fs22 = __require("fs");
     var path38 = __require("path");
     var fastGlob3 = require_out4();
-    var gitIgnore2 = require_ignore2();
+    var gitIgnore2 = require_ignore3();
     var slash2 = require_slash();
     var DEFAULT_IGNORE = [
       "**/node_modules/**",
@@ -267279,7 +267652,7 @@ var import_fast_glob2, import_ignore5, ignoreFilesGlobOptions, GITIGNORE_FILES_P
 var init_ignore = __esm({
   "node_modules/.pnpm/globby@13.2.2/node_modules/globby/ignore.js"() {
     import_fast_glob2 = __toESM(require_out4(), 1);
-    import_ignore5 = __toESM(require_ignore2(), 1);
+    import_ignore5 = __toESM(require_ignore3(), 1);
     init_slash();
     init_utilities2();
     ignoreFilesGlobOptions = {

package/manypkg/index.js

@@ -11985,9 +11985,9 @@ var require_dir_glob = __commonJS({
   }
 });
 
-// node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js
+// node_modules/.pnpm/ignore@5.3.0/node_modules/ignore/index.js
 var require_ignore = __commonJS({
-  "node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.js"(exports, module) {
+  "node_modules/.pnpm/ignore@5.3.0/node_modules/ignore/index.js"(exports, module) {
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/linting-tools",
-  "version": "1.15.9",
+  "version": "1.15.11",
   "private": false,
   "description": "⚡ A package containing various linting tools used to validate syntax, enforce design standards, and format code in a Storm workspace.",
   "keywords": [