prettier 3.0.2 → 3.0.3

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
@@ -5981,9 +6255,10 @@ 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(),
+          glob: getSupportedFilesGlob().map((pattern2) => `${prefix}/**/${pattern2}`),
           input: pattern
         });
       }
@@ -6025,13 +6300,20 @@ ${message}`
     }
   }
   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]}}`;
-    }
+    supportedFilesGlob ?? (supportedFilesGlob = [...getSupportedFilesGlobWithoutCache()]);
     return supportedFilesGlob;
   }
+  function* getSupportedFilesGlobWithoutCache() {
+    for (const {
+      extensions = [],
+      filenames = []
+    } of context.languages) {
+      yield* filenames;
+      for (const extension of extensions) {
+        yield `*${extension.startsWith(".") ? extension : `.${extension}`}`;
+      }
+    }
+  }
 }
 var errorMessages = {
   globError: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "Prettier is an opinionated code formatter",
   "bin": "./bin/prettier.cjs",
   "repository": "prettier/prettier",
@@ -190,5 +190,6 @@
     "standalone.d.ts",
     "standalone.js",
     "standalone.mjs"
-  ]
+  ],
+  "preferUnplugged": true
 }