prettier 3.0.2 → 3.1.0

package/internal/cli.mjs

@@ -1197,6 +1197,264 @@ var require_common_path_prefix = __commonJS({
   }
 });
 
+// node_modules/json-buffer/index.js
+var require_json_buffer = __commonJS({
+  "node_modules/json-buffer/index.js"(exports) {
+    exports.stringify = function stringify4(o) {
+      if ("undefined" == typeof o)
+        return o;
+      if (o && Buffer.isBuffer(o))
+        return JSON.stringify(":base64:" + o.toString("base64"));
+      if (o && o.toJSON)
+        o = o.toJSON();
+      if (o && "object" === typeof o) {
+        var s = "";
+        var array2 = Array.isArray(o);
+        s = array2 ? "[" : "{";
+        var first = true;
+        for (var k in o) {
+          var ignore = "function" == typeof o[k] || !array2 && "undefined" === typeof o[k];
+          if (Object.hasOwnProperty.call(o, k) && !ignore) {
+            if (!first)
+              s += ",";
+            first = false;
+            if (array2) {
+              if (o[k] == void 0)
+                s += "null";
+              else
+                s += stringify4(o[k]);
+            } else if (o[k] !== void 0) {
+              s += stringify4(k) + ":" + stringify4(o[k]);
+            }
+          }
+        }
+        s += array2 ? "]" : "}";
+        return s;
+      } else if ("string" === typeof o) {
+        return JSON.stringify(/^:/.test(o) ? ":" + o : o);
+      } else if ("undefined" === typeof o) {
+        return "null";
+      } else
+        return JSON.stringify(o);
+    };
+    exports.parse = function(s) {
+      return JSON.parse(s, function(key, value) {
+        if ("string" === typeof value) {
+          if (/^:base64:/.test(value))
+            return Buffer.from(value.substring(8), "base64");
+          else
+            return /^:/.test(value) ? value.substring(1) : value;
+        }
+        return value;
+      });
+    };
+  }
+});
+
+// node_modules/keyv/src/index.js
+var require_src = __commonJS({
+  "node_modules/keyv/src/index.js"(exports, module) {
+    "use strict";
+    var EventEmitter = __require("events");
+    var JSONB = require_json_buffer();
+    var loadStore = (options) => {
+      const adapters = {
+        redis: "@keyv/redis",
+        rediss: "@keyv/redis",
+        mongodb: "@keyv/mongo",
+        mongo: "@keyv/mongo",
+        sqlite: "@keyv/sqlite",
+        postgresql: "@keyv/postgres",
+        postgres: "@keyv/postgres",
+        mysql: "@keyv/mysql",
+        etcd: "@keyv/etcd",
+        offline: "@keyv/offline",
+        tiered: "@keyv/tiered"
+      };
+      if (options.adapter || options.uri) {
+        const adapter = options.adapter || /^[^:+]*/.exec(options.uri)[0];
+        return new (__require(adapters[adapter]))(options);
+      }
+      return /* @__PURE__ */ new Map();
+    };
+    var iterableAdapters = [
+      "sqlite",
+      "postgres",
+      "mysql",
+      "mongo",
+      "redis",
+      "tiered"
+    ];
+    var Keyv = class extends EventEmitter {
+      constructor(uri, { emitErrors = true, ...options } = {}) {
+        super();
+        this.opts = {
+          namespace: "keyv",
+          serialize: JSONB.stringify,
+          deserialize: JSONB.parse,
+          ...typeof uri === "string" ? { uri } : uri,
+          ...options
+        };
+        if (!this.opts.store) {
+          const adapterOptions = { ...this.opts };
+          this.opts.store = loadStore(adapterOptions);
+        }
+        if (this.opts.compression) {
+          const compression = this.opts.compression;
+          this.opts.serialize = compression.serialize.bind(compression);
+          this.opts.deserialize = compression.deserialize.bind(compression);
+        }
+        if (typeof this.opts.store.on === "function" && emitErrors) {
+          this.opts.store.on("error", (error) => this.emit("error", error));
+        }
+        this.opts.store.namespace = this.opts.namespace;
+        const generateIterator = (iterator) => async function* () {
+          for await (const [key, raw] of typeof iterator === "function" ? iterator(this.opts.store.namespace) : iterator) {
+            const data = await this.opts.deserialize(raw);
+            if (this.opts.store.namespace && !key.includes(this.opts.store.namespace)) {
+              continue;
+            }
+            if (typeof data.expires === "number" && Date.now() > data.expires) {
+              this.delete(key);
+              continue;
+            }
+            yield [this._getKeyUnprefix(key), data.value];
+          }
+        };
+        if (typeof this.opts.store[Symbol.iterator] === "function" && this.opts.store instanceof Map) {
+          this.iterator = generateIterator(this.opts.store);
+        } else if (typeof this.opts.store.iterator === "function" && this.opts.store.opts && this._checkIterableAdaptar()) {
+          this.iterator = generateIterator(this.opts.store.iterator.bind(this.opts.store));
+        }
+      }
+      _checkIterableAdaptar() {
+        return iterableAdapters.includes(this.opts.store.opts.dialect) || iterableAdapters.findIndex((element) => this.opts.store.opts.url.includes(element)) >= 0;
+      }
+      _getKeyPrefix(key) {
+        return `${this.opts.namespace}:${key}`;
+      }
+      _getKeyPrefixArray(keys) {
+        return keys.map((key) => `${this.opts.namespace}:${key}`);
+      }
+      _getKeyUnprefix(key) {
+        return key.split(":").splice(1).join(":");
+      }
+      get(key, options) {
+        const { store } = this.opts;
+        const isArray = Array.isArray(key);
+        const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key);
+        if (isArray && store.getMany === void 0) {
+          const promises = [];
+          for (const key2 of keyPrefixed) {
+            promises.push(
+              Promise.resolve().then(() => store.get(key2)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
+                if (data === void 0 || data === null) {
+                  return void 0;
+                }
+                if (typeof data.expires === "number" && Date.now() > data.expires) {
+                  return this.delete(key2).then(() => void 0);
+                }
+                return options && options.raw ? data : data.value;
+              })
+            );
+          }
+          return Promise.allSettled(promises).then((values) => {
+            const data = [];
+            for (const value of values) {
+              data.push(value.value);
+            }
+            return data;
+          });
+        }
+        return Promise.resolve().then(() => isArray ? store.getMany(keyPrefixed) : store.get(keyPrefixed)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => {
+          if (data === void 0 || data === null) {
+            return void 0;
+          }
+          if (isArray) {
+            const result = [];
+            for (let row of data) {
+              if (typeof row === "string") {
+                row = this.opts.deserialize(row);
+              }
+              if (row === void 0 || row === null) {
+                result.push(void 0);
+                continue;
+              }
+              if (typeof row.expires === "number" && Date.now() > row.expires) {
+                this.delete(key).then(() => void 0);
+                result.push(void 0);
+              } else {
+                result.push(options && options.raw ? row : row.value);
+              }
+            }
+            return result;
+          }
+          if (typeof data.expires === "number" && Date.now() > data.expires) {
+            return this.delete(key).then(() => void 0);
+          }
+          return options && options.raw ? data : data.value;
+        });
+      }
+      set(key, value, ttl) {
+        const keyPrefixed = this._getKeyPrefix(key);
+        if (typeof ttl === "undefined") {
+          ttl = this.opts.ttl;
+        }
+        if (ttl === 0) {
+          ttl = void 0;
+        }
+        const { store } = this.opts;
+        return Promise.resolve().then(() => {
+          const expires = typeof ttl === "number" ? Date.now() + ttl : null;
+          if (typeof value === "symbol") {
+            this.emit("error", "symbol cannot be serialized");
+          }
+          value = { value, expires };
+          return this.opts.serialize(value);
+        }).then((value2) => store.set(keyPrefixed, value2, ttl)).then(() => true);
+      }
+      delete(key) {
+        const { store } = this.opts;
+        if (Array.isArray(key)) {
+          const keyPrefixed2 = this._getKeyPrefixArray(key);
+          if (store.deleteMany === void 0) {
+            const promises = [];
+            for (const key2 of keyPrefixed2) {
+              promises.push(store.delete(key2));
+            }
+            return Promise.allSettled(promises).then((values) => values.every((x) => x.value === true));
+          }
+          return Promise.resolve().then(() => store.deleteMany(keyPrefixed2));
+        }
+        const keyPrefixed = this._getKeyPrefix(key);
+        return Promise.resolve().then(() => store.delete(keyPrefixed));
+      }
+      clear() {
+        const { store } = this.opts;
+        return Promise.resolve().then(() => store.clear());
+      }
+      has(key) {
+        const keyPrefixed = this._getKeyPrefix(key);
+        const { store } = this.opts;
+        return Promise.resolve().then(async () => {
+          if (typeof store.has === "function") {
+            return store.has(keyPrefixed);
+          }
+          const value = await store.get(keyPrefixed);
+          return value !== void 0;
+        });
+      }
+      disconnect() {
+        const { store } = this.opts;
+        if (typeof store.disconnect === "function") {
+          return store.disconnect();
+        }
+      }
+    };
+    module.exports = Keyv;
+  }
+});
+
 // node_modules/flatted/cjs/index.js
 var require_cjs = __commonJS({
   "node_modules/flatted/cjs/index.js"(exports) {
@@ -4008,6 +4266,7 @@ var require_cache = __commonJS({
   "node_modules/flat-cache/src/cache.js"(exports, module) {
     var path10 = __require("path");
     var fs6 = __require("fs");
+    var Keyv = require_src();
     var utils = require_utils();
     var del = require_del();
     var writeJSON = utils.writeJSON;
@@ -4023,13 +4282,28 @@ var require_cache = __commonJS({
        */
       load: function(docId, cacheDir) {
         var me = this;
-        me._visited = {};
-        me._persisted = {};
+        me.keyv = new Keyv();
+        me.__visited = {};
+        me.__persisted = {};
         me._pathToFile = cacheDir ? path10.resolve(cacheDir, docId) : path10.resolve(__dirname, "../.cache/", docId);
         if (fs6.existsSync(me._pathToFile)) {
           me._persisted = utils.tryParse(me._pathToFile, {});
         }
       },
+      get _persisted() {
+        return this.__persisted;
+      },
+      set _persisted(value) {
+        this.__persisted = value;
+        this.keyv.set("persisted", value);
+      },
+      get _visited() {
+        return this.__visited;
+      },
+      set _visited(value) {
+        this.__visited = value;
+        this.keyv.set("visited", value);
+      },
       /**
        * Load the cache from the provided file
        * @method loadFile
@@ -5930,18 +6204,27 @@ import path2 from "path";
 async function* expandPatterns(context) {
   const seen = /* @__PURE__ */ new Set();
   let noResults = true;
-  for await (const pathOrError of expandPatternsInternal(context)) {
+  for await (const {
+    filePath,
+    ignoreUnknown,
+    error
+  } of expandPatternsInternal(context)) {
     noResults = false;
-    if (typeof pathOrError !== "string") {
-      yield pathOrError;
+    if (error) {
+      yield {
+        error
+      };
       continue;
     }
-    const fileName = path2.resolve(pathOrError);
-    if (seen.has(fileName)) {
+    const filename = path2.resolve(filePath);
+    if (seen.has(filename)) {
       continue;
     }
-    seen.add(fileName);
-    yield fileName;
+    seen.add(filename);
+    yield {
+      filename,
+      ignoreUnknown
+    };
   }
   if (noResults && context.argv.errorOnUnmatchedPattern !== false) {
     yield {
@@ -5959,7 +6242,6 @@ async function* expandPatternsInternal(context) {
     ignore: silentlyIgnoredDirs.map((dir) => "**/" + dir),
     followSymbolicLinks: false
   };
-  let supportedFilesGlob;
   const cwd2 = process.cwd();
   const entries = [];
   for (const pattern of context.filePatterns) {
@@ -5981,10 +6263,12 @@ async function* expandPatternsInternal(context) {
         });
       } else if (stat.isDirectory()) {
         const relativePath = path2.relative(cwd2, absolutePath) || ".";
+        const prefix = escapePathForGlob(fixWindowsSlashes(relativePath));
         entries.push({
           type: "dir",
-          glob: escapePathForGlob(fixWindowsSlashes(relativePath)) + "/" + getSupportedFilesGlob(),
-          input: pattern
+          glob: `${prefix}/**/*`,
+          input: pattern,
+          ignoreUnknown: true
         });
       }
     } else if (pattern[0] === "!") {
@@ -6000,7 +6284,8 @@ async function* expandPatternsInternal(context) {
   for (const {
     type,
     glob,
-    input
+    input,
+    ignoreUnknown
   } of entries) {
     let result;
     try {
@@ -6021,17 +6306,12 @@ ${message}`
         };
       }
     } else {
-      yield* sortPaths(result);
+      yield* sortPaths(result).map((filePath) => ({
+        filePath,
+        ignoreUnknown
+      }));
     }
   }
-  function getSupportedFilesGlob() {
-    if (!supportedFilesGlob) {
-      const extensions = context.languages.flatMap((lang) => lang.extensions || []);
-      const filenames = context.languages.flatMap((lang) => lang.filenames || []);
-      supportedFilesGlob = `**/{${[...extensions.map((ext) => "*" + (ext[0] === "." ? ext : "." + ext)), ...filenames]}}`;
-    }
-    return supportedFilesGlob;
-  }
 }
 var errorMessages = {
   globError: {
@@ -6367,9 +6647,6 @@ function useDirectory(directory, options) {
   if (options.create) {
     fs3.mkdirSync(directory, { recursive: true });
   }
-  if (options.thunk) {
-    return (...arguments_) => path6.join(directory, ...arguments_);
-  }
   return directory;
 }
 function getNodeModuleDirectory(directory) {
@@ -6383,9 +6660,12 @@ function findCacheDirectory(options = {}) {
   if (env2.CACHE_DIR && !["true", "false", "1", "0"].includes(env2.CACHE_DIR)) {
     return useDirectory(path6.join(env2.CACHE_DIR, options.name), options);
   }
-  let { cwd: directory = cwd() } = options;
-  if (options.files) {
-    directory = (0, import_common_path_prefix.default)(options.files.map((file) => path6.resolve(directory, file)));
+  let { cwd: directory = cwd(), files } = options;
+  if (files) {
+    if (!Array.isArray(files)) {
+      throw new TypeError(`Expected \`files\` option to be an array, got \`${typeof files}\`.`);
+    }
+    directory = (0, import_common_path_prefix.default)(files.map((file) => path6.resolve(directory, file)));
   }
   directory = packageDirectorySync({ cwd: directory });
   if (!directory) {
@@ -6511,17 +6791,18 @@ function diff(a, b) {
 var DebugError = class extends Error {
   name = "DebugError";
 };
-function handleError(context, filename, error, printedFilename) {
+function handleError(context, filename, error, printedFilename, ignoreUnknown) {
+  ignoreUnknown || (ignoreUnknown = context.argv.ignoreUnknown);
   const errorIsUndefinedParseError = error instanceof errors.UndefinedParserError;
   if (printedFilename) {
-    if ((context.argv.write || context.argv.ignoreUnknown) && errorIsUndefinedParseError) {
+    if ((context.argv.write || ignoreUnknown) && errorIsUndefinedParseError) {
       printedFilename.clear();
     } else {
       process.stdout.write("\n");
     }
   }
   if (errorIsUndefinedParseError) {
-    if (context.argv.ignoreUnknown) {
+    if (ignoreUnknown) {
       return;
     }
     if (!context.argv.check && !context.argv.listDifferent) {
@@ -6732,27 +7013,20 @@ async function formatFiles(context) {
       cacheFilePath,
       context.argv.cacheStrategy || "content"
     );
-  } else {
-    if (context.argv.cacheStrategy) {
-      context.logger.error(
-        "`--cache-strategy` cannot be used without `--cache`."
-      );
-      process.exit(2);
-    }
-    if (!context.argv.cacheLocation) {
-      const stat = await statSafe(cacheFilePath);
-      if (stat) {
-        await fs5.unlink(cacheFilePath);
-      }
+  } else if (!context.argv.cacheLocation) {
+    const stat = await statSafe(cacheFilePath);
+    if (stat) {
+      await fs5.unlink(cacheFilePath);
     }
   }
-  for await (const pathOrError of expandPatterns(context)) {
-    if (typeof pathOrError === "object") {
-      context.logger.error(pathOrError.error);
+  for await (const { error, filename, ignoreUnknown } of expandPatterns(
+    context
+  )) {
+    if (error) {
+      context.logger.error(error);
       process.exitCode = 2;
       continue;
     }
-    const filename = pathOrError;
     const isFileIgnored = isIgnored(filename);
     if (isFileIgnored && (context.argv.debugCheck || context.argv.write || context.argv.check || context.argv.listDifferent)) {
       continue;
@@ -6772,11 +7046,11 @@ async function formatFiles(context) {
     let input;
     try {
       input = await fs5.readFile(filename, "utf8");
-    } catch (error) {
+    } catch (error2) {
       context.logger.log("");
       context.logger.error(
         `Unable to read file "${fileNameToDisplay}":
-${error.message}`
+${error2.message}`
       );
       process.exitCode = 2;
       continue;
@@ -6800,8 +7074,14 @@ ${error.message}`
         result = await format2(context, input, options);
       }
       output = result.formatted;
-    } catch (error) {
-      handleError(context, fileNameToDisplay, error, printedFilename);
+    } catch (error2) {
+      handleError(
+        context,
+        fileNameToDisplay,
+        error2,
+        printedFilename,
+        ignoreUnknown
+      );
       continue;
     }
     const isDifferent = output !== input;
@@ -6821,15 +7101,15 @@ ${error.message}`
         try {
           await writeFormattedFile(filename, output);
           shouldSetCache = true;
-        } catch (error) {
+        } catch (error2) {
           context.logger.error(
             `Unable to write file "${fileNameToDisplay}":
-${error.message}`
+${error2.message}`
           );
           process.exitCode = 2;
         }
       } else if (!context.argv.check && !context.argv.listDifferent) {
-        const message = `${source_default.grey(fileNameToDisplay)} ${Date.now() - start}ms`;
+        const message = `${source_default.grey(fileNameToDisplay)} ${Date.now() - start}ms (unchanged)`;
         if (isCacheExists) {
           context.logger.log(`${message} (cached)`);
         } else {
@@ -6927,7 +7207,7 @@ async function printSupportInfo() {
 var print_support_info_default = printSupportInfo;
 
 // src/cli/index.js
-async function run(rawArguments) {
+async function run(rawArguments = process.argv.slice(2)) {
   let logger = logger_default();
   try {
     const { logLevel } = parseArgvWithoutPlugins(
@@ -6963,6 +7243,9 @@ async function main(context) {
   if (context.argv.fileInfo && context.filePatterns.length > 0) {
     throw new Error("Cannot use --file-info with multiple files");
   }
+  if (!context.argv.cache && context.argv.cacheStrategy) {
+    throw new Error("`--cache-strategy` cannot be used without `--cache`.");
+  }
   if (context.argv.version) {
     printToScreen(prettier2.version);
     return;
@@ -6976,24 +7259,29 @@ async function main(context) {
   if (context.argv.supportInfo) {
     return print_support_info_default();
   }
-  const hasFilePatterns = context.filePatterns.length > 0;
-  const useStdin = !hasFilePatterns && (!process.stdin.isTTY || context.argv.filePath);
   if (context.argv.findConfigPath) {
     await find_config_path_default(context);
-  } else if (context.argv.fileInfo) {
+    return;
+  }
+  if (context.argv.fileInfo) {
     await file_info_default(context);
-  } else if (useStdin) {
+    return;
+  }
+  const hasFilePatterns = context.filePatterns.length > 0;
+  const useStdin = !hasFilePatterns && (!process.stdin.isTTY || context.argv.filepath);
+  if (useStdin) {
     if (context.argv.cache) {
-      context.logger.error("`--cache` cannot be used with stdin.");
-      process.exit(2);
+      throw new Error("`--cache` cannot be used when formatting stdin.");
     }
     await formatStdin(context);
-  } else if (hasFilePatterns) {
+    return;
+  }
+  if (hasFilePatterns) {
     await formatFiles(context);
-  } else {
-    process.exitCode = 1;
-    printToScreen(createUsage(context));
+    return;
   }
+  process.exitCode = 1;
+  printToScreen(createUsage(context));
 }
 export {
   run