@alexlit/lint-kit 182.2.0 → 182.4.0

package/packages/config-stylelint/node_modules/flat-cache/dist/index.js

@@ -1,455 +0,0 @@
-// src/index.ts
-import fs from "fs";
-import path from "path";
-import { CacheableMemory } from "cacheable";
-import { parse, stringify } from "flatted";
-import { Hookified } from "hookified";
-var FlatCacheEvents = /* @__PURE__ */ ((FlatCacheEvents2) => {
-  FlatCacheEvents2["SAVE"] = "save";
-  FlatCacheEvents2["LOAD"] = "load";
-  FlatCacheEvents2["DELETE"] = "delete";
-  FlatCacheEvents2["CLEAR"] = "clear";
-  FlatCacheEvents2["DESTROY"] = "destroy";
-  FlatCacheEvents2["ERROR"] = "error";
-  FlatCacheEvents2["EXPIRED"] = "expired";
-  return FlatCacheEvents2;
-})(FlatCacheEvents || {});
-var FlatCache = class extends Hookified {
-  _cache = new CacheableMemory();
-  _cacheDir = ".cache";
-  _cacheId = "cache1";
-  _persistInterval = 0;
-  _persistTimer;
-  _changesSinceLastSave = false;
-  _parse = parse;
-  _stringify = stringify;
-  constructor(options) {
-    super();
-    if (options) {
-      this._cache = new CacheableMemory({
-        ttl: options.ttl,
-        useClone: options.useClone,
-        lruSize: options.lruSize,
-        checkInterval: options.expirationInterval
-      });
-    }
-    if (options?.cacheDir) {
-      this._cacheDir = options.cacheDir;
-    }
-    if (options?.cacheId) {
-      this._cacheId = options.cacheId;
-    }
-    if (options?.persistInterval) {
-      this._persistInterval = options.persistInterval;
-      this.startAutoPersist();
-    }
-    if (options?.deserialize) {
-      this._parse = options.deserialize;
-    }
-    if (options?.serialize) {
-      this._stringify = options.serialize;
-    }
-  }
-  /**
-   * The cache object
-   * @property cache
-   * @type {CacheableMemory}
-   */
-  get cache() {
-    return this._cache;
-  }
-  /**
-   * The cache directory
-   * @property cacheDir
-   * @type {String}
-   * @default '.cache'
-   */
-  get cacheDir() {
-    return this._cacheDir;
-  }
-  /**
-   * Set the cache directory
-   * @property cacheDir
-   * @type {String}
-   * @default '.cache'
-   */
-  set cacheDir(value) {
-    this._cacheDir = value;
-  }
-  /**
-   * The cache id
-   * @property cacheId
-   * @type {String}
-   * @default 'cache1'
-   */
-  get cacheId() {
-    return this._cacheId;
-  }
-  /**
-   * Set the cache id
-   * @property cacheId
-   * @type {String}
-   * @default 'cache1'
-   */
-  set cacheId(value) {
-    this._cacheId = value;
-  }
-  /**
-   * The flag to indicate if there are changes since the last save
-   * @property changesSinceLastSave
-   * @type {Boolean}
-   * @default false
-   */
-  get changesSinceLastSave() {
-    return this._changesSinceLastSave;
-  }
-  /**
-   * The interval to persist the cache to disk. 0 means no timed persistence
-   * @property persistInterval
-   * @type {Number}
-   * @default 0
-   */
-  get persistInterval() {
-    return this._persistInterval;
-  }
-  /**
-   * Set the interval to persist the cache to disk. 0 means no timed persistence
-   * @property persistInterval
-   * @type {Number}
-   * @default 0
-   */
-  set persistInterval(value) {
-    this._persistInterval = value;
-  }
-  /**
-   * Load a cache identified by the given Id. If the element does not exists, then initialize an empty
-   * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted
-   * then the cache module directory `.cacheDir` will be used instead
-   *
-   * @method load
-   * @param cacheId {String} the id of the cache, would also be used as the name of the file cache
-   * @param cacheDir {String} directory for the cache entry
-   */
-  load(cacheId, cacheDir) {
-    try {
-      const filePath = path.resolve(
-        `${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`
-      );
-      this.loadFile(filePath);
-      this.emit("load" /* LOAD */);
-    } catch (error) {
-      this.emit("error" /* ERROR */, error);
-    }
-  }
-  /**
-   * Load the cache from the provided file
-   * @method loadFile
-   * @param  {String} pathToFile the path to the file containing the info for the cache
-   */
-  loadFile(pathToFile) {
-    if (fs.existsSync(pathToFile)) {
-      const data = fs.readFileSync(pathToFile, "utf8");
-      const items = this._parse(data);
-      if (Array.isArray(items)) {
-        for (const item of items) {
-          if (item && typeof item === "object" && "key" in item) {
-            if (item.expires) {
-              this._cache.set(item.key, item.value, { expire: item.expires });
-            } else if (item.timestamp) {
-              this._cache.set(item.key, item.value, { expire: item.timestamp });
-            } else {
-              this._cache.set(item.key, item.value);
-            }
-          }
-        }
-      } else {
-        for (const key of Object.keys(items)) {
-          const item = items[key];
-          if (item && typeof item === "object" && "key" in item) {
-            this._cache.set(item.key, item.value, {
-              expire: item.expires
-            });
-          } else {
-            if (item && typeof item === "object" && item.timestamp) {
-              this._cache.set(key, item, { expire: item.timestamp });
-            } else {
-              this._cache.set(key, item);
-            }
-          }
-        }
-      }
-      this._changesSinceLastSave = true;
-    }
-  }
-  loadFileStream(pathToFile, onProgress, onEnd, onError) {
-    if (fs.existsSync(pathToFile)) {
-      const stats = fs.statSync(pathToFile);
-      const total = stats.size;
-      let loaded = 0;
-      let streamData = "";
-      const readStream = fs.createReadStream(pathToFile, { encoding: "utf8" });
-      readStream.on("data", (chunk) => {
-        loaded += chunk.length;
-        streamData += chunk;
-        onProgress(loaded, total);
-      });
-      readStream.on("end", () => {
-        const items = this._parse(streamData);
-        for (const key of Object.keys(items)) {
-          this._cache.set(items[key].key, items[key].value, {
-            expire: items[key].expires
-          });
-        }
-        this._changesSinceLastSave = true;
-        onEnd();
-      });
-      readStream.on("error", (error) => {
-        this.emit("error" /* ERROR */, error);
-        if (onError) {
-          onError(error);
-        }
-      });
-    } else {
-      const error = new Error(`Cache file ${pathToFile} does not exist`);
-      this.emit("error" /* ERROR */, error);
-      if (onError) {
-        onError(error);
-      }
-    }
-  }
-  /**
-   * Returns the entire persisted object
-   * @method all
-   * @returns {*}
-   */
-  all() {
-    const result = {};
-    const items = [...this._cache.items];
-    for (const item of items) {
-      result[item.key] = item.value;
-    }
-    return result;
-  }
-  /**
-   * Returns an array with all the items in the cache { key, value, expires }
-   * @method items
-   * @returns {Array}
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: cache items can store any value
-  get items() {
-    return [...this._cache.items];
-  }
-  /**
-   * Returns the path to the file where the cache is persisted
-   * @method cacheFilePath
-   * @returns {String}
-   */
-  get cacheFilePath() {
-    return path.resolve(`${this._cacheDir}/${this._cacheId}`);
-  }
-  /**
-   * Returns the path to the cache directory
-   * @method cacheDirPath
-   * @returns {String}
-   */
-  get cacheDirPath() {
-    return path.resolve(this._cacheDir);
-  }
-  /**
-   * Returns an array with all the keys in the cache
-   * @method keys
-   * @returns {Array}
-   */
-  keys() {
-    return [...this._cache.keys];
-  }
-  /**
-   * (Legacy) set key method. This method will be deprecated in the future
-   * @method setKey
-   * @param key {string} the key to set
-   * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  setKey(key, value, ttl) {
-    this.set(key, value, ttl);
-  }
-  /**
-   * Sets a key to a given value
-   * @method set
-   * @param key {string} the key to set
-   * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
-   * @param [ttl] {number} the time to live in milliseconds
-   */
-  // biome-ignore lint/suspicious/noExplicitAny: type format
-  set(key, value, ttl) {
-    this._cache.set(key, value, ttl);
-    this._changesSinceLastSave = true;
-  }
-  /**
-   * (Legacy) Remove a given key from the cache. This method will be deprecated in the future
-   * @method removeKey
-   * @param key {String} the key to remove from the object
-   */
-  removeKey(key) {
-    this.delete(key);
-  }
-  /**
-   * Remove a given key from the cache
-   * @method delete
-   * @param key {String} the key to remove from the object
-   */
-  delete(key) {
-    this._cache.delete(key);
-    this._changesSinceLastSave = true;
-    this.emit("delete" /* DELETE */, key);
-  }
-  /**
-   * (Legacy) Return the value of the provided key. This method will be deprecated in the future
-   * @method getKey<T>
-   * @param key {String} the name of the key to retrieve
-   * @returns {*} at T the value from the key
-   */
-  getKey(key) {
-    return this.get(key);
-  }
-  /**
-   * Return the value of the provided key
-   * @method get<T>
-   * @param key {String} the name of the key to retrieve
-   * @returns {*} at T the value from the key
-   */
-  get(key) {
-    return this._cache.get(key);
-  }
-  /**
-   * Clear the cache and save the state to disk
-   * @method clear
-   */
-  clear() {
-    try {
-      this._cache.clear();
-      this._changesSinceLastSave = true;
-      this.save();
-      this.emit("clear" /* CLEAR */);
-    } catch (error) {
-      this.emit("error" /* ERROR */, error);
-    }
-  }
-  /**
-   * Save the state of the cache identified by the docId to disk
-   * as a JSON structure
-   * @method save
-   */
-  save(force = false) {
-    try {
-      if (this._changesSinceLastSave || force) {
-        const filePath = this.cacheFilePath;
-        const items = [...this._cache.items];
-        const data = this._stringify(items);
-        if (!fs.existsSync(this._cacheDir)) {
-          fs.mkdirSync(this._cacheDir, { recursive: true });
-        }
-        fs.writeFileSync(filePath, data);
-        this._changesSinceLastSave = false;
-        this.emit("save" /* SAVE */);
-      }
-    } catch (error) {
-      this.emit("error" /* ERROR */, error);
-    }
-  }
-  /**
-   * Remove the file where the cache is persisted
-   * @method removeCacheFile
-   * @return {Boolean} true or false if the file was successfully deleted
-   */
-  removeCacheFile() {
-    try {
-      if (fs.existsSync(this.cacheFilePath)) {
-        fs.rmSync(this.cacheFilePath);
-        return true;
-      }
-    } catch (error) {
-      this.emit("error" /* ERROR */, error);
-    }
-    return false;
-  }
-  /**
-   * Destroy the cache. This will remove the directory, file, and memory cache
-   * @method destroy
-   * @param [includeCacheDir=false] {Boolean} if true, the cache directory will be removed
-   * @return {undefined}
-   */
-  destroy(includeCacheDirectory = false) {
-    try {
-      this._cache.clear();
-      this.stopAutoPersist();
-      if (includeCacheDirectory) {
-        fs.rmSync(this.cacheDirPath, { recursive: true, force: true });
-      } else {
-        fs.rmSync(this.cacheFilePath, { recursive: true, force: true });
-      }
-      this._changesSinceLastSave = false;
-      this.emit("destroy" /* DESTROY */);
-    } catch (error) {
-      this.emit("error" /* ERROR */, error);
-    }
-  }
-  /**
-   * Start the auto persist interval
-   * @method startAutoPersist
-   */
-  startAutoPersist() {
-    if (this._persistInterval > 0) {
-      if (this._persistTimer) {
-        clearInterval(this._persistTimer);
-        this._persistTimer = void 0;
-      }
-      this._persistTimer = setInterval(() => {
-        this.save();
-      }, this._persistInterval);
-    }
-  }
-  /**
-   * Stop the auto persist interval
-   * @method stopAutoPersist
-   */
-  stopAutoPersist() {
-    if (this._persistTimer) {
-      clearInterval(this._persistTimer);
-      this._persistTimer = void 0;
-    }
-  }
-};
-var FlatCacheDefault = class {
-  static create = create;
-  static createFromFile = createFromFile;
-  static clearCacheById = clearCacheById;
-  static clearAll = clearAll;
-};
-function create(options) {
-  const cache = new FlatCache(options);
-  cache.load();
-  return cache;
-}
-function createFromFile(filePath, options) {
-  const cache = new FlatCache(options);
-  cache.loadFile(filePath);
-  return cache;
-}
-function clearCacheById(cacheId, cacheDirectory) {
-  const cache = new FlatCache({ cacheId, cacheDir: cacheDirectory });
-  cache.destroy();
-}
-function clearAll(cacheDirectory) {
-  fs.rmSync(cacheDirectory ?? ".cache", { recursive: true, force: true });
-}
-export {
-  FlatCache,
-  FlatCacheEvents,
-  clearAll,
-  clearCacheById,
-  create,
-  createFromFile,
-  FlatCacheDefault as default
-};
-/* v8 ignore next -- @preserve */

package/packages/config-stylelint/node_modules/flat-cache/package.json

@@ -1,87 +0,0 @@
-{
-  "name": "flat-cache",
-  "version": "6.1.20",
-  "description": "A simple key/value storage using files to persist the data",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jaredwray/cacheable.git",
-    "directory": "packages/flat-cache"
-  },
-  "author": "Jared Wray <me@jaredwray.com>",
-  "license": "MIT",
-  "private": false,
-  "keywords": [
-    "cache",
-    "caching",
-    "cacheable",
-    "flat-cache",
-    "flat",
-    "file",
-    "file-cache",
-    "file-caching",
-    "file-based-cache",
-    "file-persist",
-    "file-persistence",
-    "file-storage",
-    "file-system",
-    "file-management",
-    "filesystem-cache",
-    "disk-cache",
-    "cache-persistence",
-    "cache-persist",
-    "persistent-cache",
-    "persistent-storage",
-    "cache-to-file",
-    "cache-on-disk",
-    "cache-file",
-    "cache-expiration",
-    "cache-lifetime",
-    "data-persistence",
-    "data-storage",
-    "local-storage",
-    "file-system-cache"
-  ],
-  "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
-    "@faker-js/faker": "^10.2.0",
-    "@types/node": "^25.0.8",
-    "@vitest/coverage-v8": "^4.0.17",
-    "rimraf": "^6.1.2",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.17"
-  },
-  "dependencies": {
-    "flatted": "^3.3.3",
-    "hookified": "^1.15.0",
-    "cacheable": "^2.3.2"
-  },
-  "files": [
-    "dist",
-    "license"
-  ],
-  "scripts": {
-    "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
-    "prepublish": "pnpm build",
-    "lint": "biome check --write --error-on-warnings",
-    "test": "pnpm lint && vitest run --coverage",
-    "test:ci": "biome check --error-on-warnings && vitest run --coverage",
-    "clean": "rimraf ./dist ./coverage ./node_modules"
-  }
-}