@kitschpatrol/shared-config 5.7.0 → 5.7.2

package/bin/cli.js

@@ -11084,7 +11084,7 @@ var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 
 // ../../package.json
-var version = "5.7.0";
+var version = "5.7.2";
 
 // ../../src/execa-utilities.ts
 function isErrorExecaError(error) {
@@ -12356,14 +12356,15 @@ var commandDefinition6 = {
   order: 8
 };
 
-// ../../node_modules/.pnpm/globby@14.1.0/node_modules/globby/index.js
+// ../../node_modules/.pnpm/globby@15.0.0/node_modules/globby/index.js
 import process5 from "node:process";
 import fs6 from "node:fs";
 import nodePath from "node:path";
+import { Readable } from "node:stream";
 
-// ../../node_modules/.pnpm/@sindresorhus+merge-streams@2.3.0/node_modules/@sindresorhus/merge-streams/index.js
+// ../../node_modules/.pnpm/@sindresorhus+merge-streams@4.0.0/node_modules/@sindresorhus/merge-streams/index.js
 import { on, once } from "node:events";
-import { PassThrough as PassThroughStream } from "node:stream";
+import { PassThrough as PassThroughStream, getDefaultHighWaterMark } from "node:stream";
 import { finished } from "node:stream/promises";
 function mergeStreams(streams) {
   if (!Array.isArray(streams)) {
@@ -12382,14 +12383,11 @@ function mergeStreams(streams) {
   for (const stream of streams) {
     passThroughStream.add(stream);
   }
-  if (streams.length === 0) {
-    endStream(passThroughStream);
-  }
   return passThroughStream;
 }
 var getHighWaterMark = (streams, objectMode) => {
   if (streams.length === 0) {
-    return 16384;
+    return getDefaultHighWaterMark(objectMode);
   }
   const highWaterMarks = streams.filter(({ readableObjectMode }) => readableObjectMode === objectMode).map(({ readableHighWaterMark }) => readableHighWaterMark);
   return Math.max(...highWaterMarks);
@@ -12399,39 +12397,49 @@ var MergedStream = class extends PassThroughStream {
   #ended = /* @__PURE__ */ new Set([]);
   #aborted = /* @__PURE__ */ new Set([]);
   #onFinished;
+  #unpipeEvent = Symbol("unpipe");
+  #streamPromises = /* @__PURE__ */ new WeakMap();
   add(stream) {
     validateStream(stream);
     if (this.#streams.has(stream)) {
       return;
     }
     this.#streams.add(stream);
-    this.#onFinished ??= onMergedStreamFinished(this, this.#streams);
-    endWhenStreamsDone({
+    this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
+    const streamPromise = endWhenStreamsDone({
       passThroughStream: this,
       stream,
       streams: this.#streams,
       ended: this.#ended,
       aborted: this.#aborted,
-      onFinished: this.#onFinished
+      onFinished: this.#onFinished,
+      unpipeEvent: this.#unpipeEvent
     });
+    this.#streamPromises.set(stream, streamPromise);
     stream.pipe(this, { end: false });
   }
-  remove(stream) {
+  async remove(stream) {
     validateStream(stream);
     if (!this.#streams.has(stream)) {
       return false;
     }
+    const streamPromise = this.#streamPromises.get(stream);
+    if (streamPromise === void 0) {
+      return false;
+    }
+    this.#streamPromises.delete(stream);
     stream.unpipe(this);
+    await streamPromise;
     return true;
   }
 };
-var onMergedStreamFinished = async (passThroughStream, streams) => {
+var onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
   updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
   const controller = new AbortController();
   try {
     await Promise.race([
       onMergedStreamEnd(passThroughStream, controller),
-      onInputStreamsUnpipe(passThroughStream, streams, controller)
+      onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller)
     ]);
   } finally {
     controller.abort();
@@ -12439,9 +12447,14 @@ var onMergedStreamFinished = async (passThroughStream, streams) => {
   }
 };
 var onMergedStreamEnd = async (passThroughStream, { signal }) => {
-  await finished(passThroughStream, { signal, cleanup: true });
+  try {
+    await finished(passThroughStream, { signal, cleanup: true });
+  } catch (error) {
+    errorOrAbortStream(passThroughStream, error);
+    throw error;
+  }
 };
-var onInputStreamsUnpipe = async (passThroughStream, streams, { signal }) => {
+var onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, { signal }) => {
   for await (const [unpipedStream] of on(passThroughStream, "unpipe", { signal })) {
     if (streams.has(unpipedStream)) {
       unpipedStream.emit(unpipeEvent);
@@ -12453,20 +12466,34 @@ var validateStream = (stream) => {
     throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
   }
 };
-var endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, aborted, onFinished }) => {
+var endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, aborted, onFinished, unpipeEvent }) => {
   updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
   const controller = new AbortController();
   try {
     await Promise.race([
-      afterMergedStreamFinished(onFinished, stream),
-      onInputStreamEnd({ passThroughStream, stream, streams, ended, aborted, controller }),
-      onInputStreamUnpipe({ stream, streams, ended, aborted, controller })
+      afterMergedStreamFinished(onFinished, stream, controller),
+      onInputStreamEnd({
+        passThroughStream,
+        stream,
+        streams,
+        ended,
+        aborted,
+        controller
+      }),
+      onInputStreamUnpipe({
+        stream,
+        streams,
+        ended,
+        aborted,
+        unpipeEvent,
+        controller
+      })
     ]);
   } finally {
     controller.abort();
     updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
   }
-  if (streams.size === ended.size + aborted.size) {
+  if (streams.size > 0 && streams.size === ended.size + aborted.size) {
     if (ended.size === 0 && aborted.size > 0) {
       abortStream(passThroughStream);
     } else {
@@ -12474,22 +12501,26 @@ var endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, abo
     }
   }
 };
-var isAbortError = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE";
-var afterMergedStreamFinished = async (onFinished, stream) => {
+var afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
   try {
     await onFinished;
-    abortStream(stream);
-  } catch (error) {
-    if (isAbortError(error)) {
+    if (!signal.aborted) {
       abortStream(stream);
-    } else {
-      errorStream(stream, error);
+    }
+  } catch (error) {
+    if (!signal.aborted) {
+      errorOrAbortStream(stream, error);
     }
   }
 };
 var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, aborted, controller: { signal } }) => {
   try {
-    await finished(stream, { signal, cleanup: true, readable: true, writable: false });
+    await finished(stream, {
+      signal,
+      cleanup: true,
+      readable: true,
+      writable: false
+    });
     if (streams.has(stream)) {
       ended.add(stream);
     }
@@ -12504,18 +12535,28 @@ var onInputStreamEnd = async ({ passThroughStream, stream, streams, ended, abort
     }
   }
 };
-var onInputStreamUnpipe = async ({ stream, streams, ended, aborted, controller: { signal } }) => {
+var onInputStreamUnpipe = async ({ stream, streams, ended, aborted, unpipeEvent, controller: { signal } }) => {
   await once(stream, unpipeEvent, { signal });
+  if (!stream.readable) {
+    return once(signal, "abort", { signal });
+  }
   streams.delete(stream);
   ended.delete(stream);
   aborted.delete(stream);
 };
-var unpipeEvent = Symbol("unpipe");
 var endStream = (stream) => {
   if (stream.writable) {
     stream.end();
   }
 };
+var errorOrAbortStream = (stream, error) => {
+  if (isAbortError(error)) {
+    abortStream(stream);
+  } else {
+    errorStream(stream, error);
+  }
+};
+var isAbortError = (error) => error?.code === "ERR_STREAM_PREMATURE_CLOSE";
 var abortStream = (stream) => {
   if (stream.readable || stream.writable) {
     stream.destroy();
@@ -12538,7 +12579,7 @@ var updateMaxListeners = (passThroughStream, increment2) => {
 var PASSTHROUGH_LISTENERS_COUNT = 2;
 var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 
-// ../../node_modules/.pnpm/globby@14.1.0/node_modules/globby/index.js
+// ../../node_modules/.pnpm/globby@15.0.0/node_modules/globby/index.js
 var import_fast_glob2 = __toESM(require_out4(), 1);
 
 // ../../node_modules/.pnpm/path-type@6.0.0/node_modules/path-type/index.js
@@ -12588,7 +12629,7 @@ function toPath2(urlOrPath) {
 }
 var TEN_MEGABYTES_IN_BYTES = 10 * 1024 * 1024;
 
-// ../../node_modules/.pnpm/globby@14.1.0/node_modules/globby/ignore.js
+// ../../node_modules/.pnpm/globby@15.0.0/node_modules/globby/ignore.js
 var import_fast_glob = __toESM(require_out4(), 1);
 var import_ignore = __toESM(require_ignore(), 1);
 import process4 from "node:process";
@@ -12605,10 +12646,10 @@ function slash(path10) {
   return path10.replace(/\\/g, "/");
 }
 
-// ../../node_modules/.pnpm/globby@14.1.0/node_modules/globby/utilities.js
+// ../../node_modules/.pnpm/globby@15.0.0/node_modules/globby/utilities.js
 var isNegativePattern = (pattern) => pattern[0] === "!";
 
-// ../../node_modules/.pnpm/globby@14.1.0/node_modules/globby/ignore.js
+// ../../node_modules/.pnpm/globby@15.0.0/node_modules/globby/ignore.js
 var defaultIgnoredDirectories = [
   "**/node_modules",
   "**/flow-typed",
@@ -12620,7 +12661,24 @@ var ignoreFilesGlobOptions = {
   dot: true
 };
 var GITIGNORE_FILES_PATTERN = "**/.gitignore";
-var applyBaseToPattern = (pattern, base) => isNegativePattern(pattern) ? "!" + path7.posix.join(base, pattern.slice(1)) : path7.posix.join(base, pattern);
+var applyBaseToPattern = (pattern, base) => {
+  if (!base) {
+    return pattern;
+  }
+  const isNegative = isNegativePattern(pattern);
+  const cleanPattern = isNegative ? pattern.slice(1) : pattern;
+  const slashIndex = cleanPattern.indexOf("/");
+  const hasNonTrailingSlash = slashIndex !== -1 && slashIndex !== cleanPattern.length - 1;
+  let result;
+  if (!hasNonTrailingSlash) {
+    result = path7.posix.join(base, "**", cleanPattern);
+  } else if (cleanPattern.startsWith("/")) {
+    result = path7.posix.join(base, cleanPattern.slice(1));
+  } else {
+    result = path7.posix.join(base, cleanPattern);
+  }
+  return isNegative ? "!" + result : result;
+};
 var parseIgnoreFile = (file, cwd) => {
   const base = slash(path7.relative(cwd, path7.dirname(file.filePath)));
   return file.content.split(/\r?\n/).filter((line) => line && !line.startsWith("#")).map((pattern) => applyBaseToPattern(pattern, base));
@@ -12633,6 +12691,12 @@ var toRelativePath = (fileOrDirectory, cwd) => {
     }
     throw new Error(`Path ${fileOrDirectory} is not in cwd ${cwd}`);
   }
+  if (fileOrDirectory.startsWith("./")) {
+    return fileOrDirectory.slice(2);
+  }
+  if (fileOrDirectory.startsWith("../")) {
+    return void 0;
+  }
   return fileOrDirectory;
 };
 var getIsIgnoredPredicate = (files, cwd) => {
@@ -12641,6 +12705,9 @@ var getIsIgnoredPredicate = (files, cwd) => {
   return (fileOrDirectory) => {
     fileOrDirectory = toPath2(fileOrDirectory);
     fileOrDirectory = toRelativePath(fileOrDirectory, cwd);
+    if (fileOrDirectory === void 0) {
+      return false;
+    }
     return fileOrDirectory ? ignores.ignores(slash(fileOrDirectory)) : false;
   };
 };
@@ -12659,12 +12726,10 @@ var isIgnoredByIgnoreFiles = async (patterns, options) => {
     ignore,
     ...ignoreFilesGlobOptions
   });
-  const files = await Promise.all(
-    paths.map(async (filePath) => ({
-      filePath,
-      content: await fsPromises3.readFile(filePath, "utf8")
-    }))
-  );
+  const files = await Promise.all(paths.map(async (filePath) => ({
+    filePath,
+    content: await fsPromises3.readFile(filePath, "utf8")
+  })));
   return getIsIgnoredPredicate(files, cwd);
 };
 var isIgnoredByIgnoreFilesSync = (patterns, options) => {
@@ -12683,7 +12748,7 @@ var isIgnoredByIgnoreFilesSync = (patterns, options) => {
   return getIsIgnoredPredicate(files, cwd);
 };
 
-// ../../node_modules/.pnpm/globby@14.1.0/node_modules/globby/index.js
+// ../../node_modules/.pnpm/globby@15.0.0/node_modules/globby/index.js
 var assertPatternsInput = (patterns) => {
   if (patterns.some((pattern) => typeof pattern !== "string")) {
     throw new TypeError("Patterns must be a string or an array of strings");
@@ -12693,6 +12758,16 @@ var normalizePathForDirectoryGlob = (filePath, cwd) => {
   const path10 = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
   return nodePath.isAbsolute(path10) ? path10 : nodePath.join(cwd, path10);
 };
+var shouldExpandGlobstarDirectory = (pattern) => {
+  const match = pattern?.match(/\*\*\/([^/]+)$/);
+  if (!match) {
+    return false;
+  }
+  const dirname3 = match[1];
+  const hasWildcards = /[*?[\]{}]/.test(dirname3);
+  const hasExtension = nodePath.extname(dirname3) && !dirname3.startsWith(".");
+  return !hasWildcards && !hasExtension;
+};
 var getDirectoryGlob = ({ directoryPath, files, extensions }) => {
   const extensionGlob = extensions?.length > 0 ? `.${extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0]}` : "";
   return files ? files.map((file) => nodePath.posix.join(directoryPath, `**/${nodePath.extname(file) ? file : `${file}${extensionGlob}`}`)) : [nodePath.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ""}`)];
@@ -12702,16 +12777,28 @@ var directoryToGlob = async (directoryPaths, {
   files,
   extensions
 } = {}) => {
-  const globs = await Promise.all(
-    directoryPaths.map(async (directoryPath) => await isDirectory(normalizePathForDirectoryGlob(directoryPath, cwd)) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath)
-  );
+  const globs = await Promise.all(directoryPaths.map(async (directoryPath) => {
+    const checkPattern = isNegativePattern(directoryPath) ? directoryPath.slice(1) : directoryPath;
+    if (shouldExpandGlobstarDirectory(checkPattern)) {
+      return getDirectoryGlob({ directoryPath, files, extensions });
+    }
+    const pathToCheck = normalizePathForDirectoryGlob(directoryPath, cwd);
+    return await isDirectory(pathToCheck) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath;
+  }));
   return globs.flat();
 };
 var directoryToGlobSync = (directoryPaths, {
   cwd = process5.cwd(),
   files,
   extensions
-} = {}) => directoryPaths.flatMap((directoryPath) => isDirectorySync(normalizePathForDirectoryGlob(directoryPath, cwd)) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath);
+} = {}) => directoryPaths.flatMap((directoryPath) => {
+  const checkPattern = isNegativePattern(directoryPath) ? directoryPath.slice(1) : directoryPath;
+  if (shouldExpandGlobstarDirectory(checkPattern)) {
+    return getDirectoryGlob({ directoryPath, files, extensions });
+  }
+  const pathToCheck = normalizePathForDirectoryGlob(directoryPath, cwd);
+  return isDirectorySync(pathToCheck) ? getDirectoryGlob({ directoryPath, files, extensions }) : directoryPath;
+});
 var toPatternsArray = (patterns) => {
   patterns = [...new Set([patterns].flat())];
   assertPatternsInput(patterns);
@@ -12753,15 +12840,11 @@ var getIgnoreFilesPatterns = (options) => {
 };
 var getFilter = async (options) => {
   const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
-  return createFilterFunction(
-    ignoreFilesPatterns.length > 0 && await isIgnoredByIgnoreFiles(ignoreFilesPatterns, options)
-  );
+  return createFilterFunction(ignoreFilesPatterns.length > 0 && await isIgnoredByIgnoreFiles(ignoreFilesPatterns, options));
 };
 var getFilterSync = (options) => {
   const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
-  return createFilterFunction(
-    ignoreFilesPatterns.length > 0 && isIgnoredByIgnoreFilesSync(ignoreFilesPatterns, options)
-  );
+  return createFilterFunction(ignoreFilesPatterns.length > 0 && isIgnoredByIgnoreFilesSync(ignoreFilesPatterns, options));
 };
 var createFilterFunction = (isIgnored) => {
   const seen = /* @__PURE__ */ new Set();
@@ -12814,19 +12897,17 @@ var generateTasks = async (patterns, options) => {
     return globTasks;
   }
   const directoryToGlobOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
-  return Promise.all(
-    globTasks.map(async (task) => {
-      let { patterns: patterns2, options: options2 } = task;
-      [
-        patterns2,
-        options2.ignore
-      ] = await Promise.all([
-        directoryToGlob(patterns2, directoryToGlobOptions),
-        directoryToGlob(options2.ignore, { cwd })
-      ]);
-      return { patterns: patterns2, options: options2 };
-    })
-  );
+  return Promise.all(globTasks.map(async (task) => {
+    let { patterns: patterns2, options: options2 } = task;
+    [
+      patterns2,
+      options2.ignore
+    ] = await Promise.all([
+      directoryToGlob(patterns2, directoryToGlobOptions),
+      directoryToGlob(options2.ignore, { cwd })
+    ]);
+    return { patterns: patterns2, options: options2 };
+  }));
 };
 var generateTasksSync = (patterns, options) => {
   const globTasks = convertNegativePatterns(patterns, options);
@@ -12863,12 +12944,13 @@ var globbyStream = normalizeArgumentsSync((patterns, options) => {
   const tasks = generateTasksSync(patterns, options);
   const filter = getFilterSync(options);
   const streams = tasks.map((task) => import_fast_glob2.default.stream(task.patterns, task.options));
+  if (streams.length === 0) {
+    return Readable.from([]);
+  }
   const stream = mergeStreams(streams).filter((fastGlobResult) => filter(fastGlobResult));
   return stream;
 });
-var isDynamicPattern = normalizeArgumentsSync(
-  (patterns, options) => patterns.some((pattern) => import_fast_glob2.default.isDynamicPattern(pattern, options))
-);
+var isDynamicPattern = normalizeArgumentsSync((patterns, options) => patterns.some((pattern) => import_fast_glob2.default.isDynamicPattern(pattern, options)));
 var generateGlobTasks = normalizeArguments(generateTasks);
 var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
 var { convertPathToPattern } = import_fast_glob2.default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitschpatrol/shared-config",
-  "version": "5.7.0",
+  "version": "5.7.2",
   "description": "A collection of shared configurations, linters, and formatting tools for TypeScript projects. All managed as a single dependency, and invoked via a single CLI command.",
   "keywords": [
     "shared-config",
@@ -42,20 +42,20 @@
     "cosmiconfig-typescript-loader": "^6.1.0",
     "execa": "^9.6.0",
     "find-workspaces": "^0.3.1",
-    "fs-extra": "^11.3.1",
+    "fs-extra": "^11.3.2",
     "prettier": "^3.6.2",
-    "@kitschpatrol/cspell-config": "5.7.0",
-    "@kitschpatrol/knip-config": "5.7.0",
-    "@kitschpatrol/eslint-config": "5.7.0",
-    "@kitschpatrol/remark-config": "5.7.0",
-    "@kitschpatrol/repo-config": "5.7.0",
-    "@kitschpatrol/prettier-config": "5.7.0",
-    "@kitschpatrol/typescript-config": "5.7.0",
-    "@kitschpatrol/mdat-config": "5.7.0",
-    "@kitschpatrol/stylelint-config": "5.7.0"
+    "@kitschpatrol/cspell-config": "5.7.2",
+    "@kitschpatrol/eslint-config": "5.7.2",
+    "@kitschpatrol/mdat-config": "5.7.2",
+    "@kitschpatrol/prettier-config": "5.7.2",
+    "@kitschpatrol/stylelint-config": "5.7.2",
+    "@kitschpatrol/remark-config": "5.7.2",
+    "@kitschpatrol/knip-config": "5.7.2",
+    "@kitschpatrol/repo-config": "5.7.2",
+    "@kitschpatrol/typescript-config": "5.7.2"
   },
   "devDependencies": {
-    "globby": "^14.1.0",
+    "globby": "^15.0.0",
     "picocolors": "^1.1.1"
   },
   "engines": {