@boundaries/elements 1.0.0 → 1.1.0

package/README.md

@@ -8,7 +8,7 @@
 
 # @boundaries/elements
 
-> Element descriptors and matchers for enforcing architectural boundaries in JavaScript/TypeScript projects
+> Element descriptors and matchers for `@boundaries` tools, such as `@boundaries/eslint-plugin`.
 
 ## Table of Contents
 
@@ -128,6 +128,7 @@ const elements = new Elements({
 - **`ignorePaths`**: Micromatch pattern(s) to exclude certain paths from element matching (default: none)
 - **`includePaths`**: Micromatch pattern(s) to include only specific paths (default: all paths)
 - **`legacyTemplates`**: Whether to enable legacy template syntax support (default: `true`, but it will be `false` in future releases). This allows using `${variable}` syntax in templates for backward compatibility.
+- **`cache`**: Whether to enable internal caching to improve performance (default: `true`)
 
 ### Creating a Matcher
 
@@ -384,7 +385,7 @@ const matcher = elements.getMatcher([
 
 ##### `clearCache`
 
-Clears all cached matcher instances.
+Clears all cached matcher instances and shared caches.
 
 ```ts
 elements.clearCache();
@@ -392,14 +393,14 @@ elements.clearCache();
 
 ##### `serializeCache`
 
-Serializes all cached matcher instances to a plain object.
+Serializes all cached matcher instances and shared caches to a plain object.
 
 ```ts
 const cache = elements.serializeCache();
 ```
 
 ##### `setCacheFromSerialized`
-Sets the cached matcher instances from a serialized object.
+Sets the cached matcher instances and shared caches from a serialized object.
 
 ```ts
 const cache = elements.serializeCache();
@@ -495,6 +496,9 @@ Clears the matcher's internal cache.
 matcher.clearCache();
 ```
 
+> [!WARNING]
+> This only clears the internal cache for this matcher instance. Shared cache for micromatch results, regex and captures is not affected. You can clear all caches using `Elements.clearCache()`.
+
 #### `serializeCache`
 
 Serializes the matcher's cache.

package/dist/index.browser.d.mts

@@ -1,5 +1,3 @@
-import { NotUndefined } from 'object-hash';
-
 /**
  * Type representing a micromatch pattern, which can be a string or an array of strings.
  */
@@ -15,11 +13,19 @@ type ConfigOptions = {
      * When enabled, it supports using "${...}" syntax in templates.
      **/
     legacyTemplates?: boolean;
+    /** Whether to enable caching */
+    cache?: boolean;
 };
-type ConfigOptionsNormalized = Omit<ConfigOptions, "legacyTemplates"> & {
+type ConfigOptionsNormalized = Omit<ConfigOptions, "legacyTemplates" | "cache"> & {
     /** Whether to enable legacy template support */
     legacyTemplates: boolean;
+    /** Cache configuration options */
+    cache: boolean;
 };
+/** Options for descriptors */
+type DescriptorOptionsNormalized = Pick<ConfigOptionsNormalized, "includePaths" | "ignorePaths" | "cache">;
+/** Options for element matchers */
+type MatchersOptionsNormalized = Pick<ConfigOptionsNormalized, "legacyTemplates">;
 
 /**
  * Map of the modes to interpret the pattern in an ElementDescriptor.
@@ -116,7 +122,20 @@ type ElementDescriptors = ElementDescriptor[];
 /**
  * Serialized cache of element descriptions.
  */
-type ElementsDescriptorSerializedCache = Record<string, ElementDescription>;
+type DescriptionsSerializedCache = Record<string, ElementDescription>;
+/**
+ * Serialized cache of file elements.
+ */
+type FileElementsSerializedCache = Record<string, FileElement>;
+/**
+ * Serialized cache for ElementsDescriptor class.
+ */
+type ElementsDescriptorSerializedCache = {
+    /** Serialized descriptions cache */
+    descriptions: DescriptionsSerializedCache;
+    /** Serialized files cache */
+    files: FileElementsSerializedCache;
+};
 /**
  * Captured values from an element path.
  */
@@ -527,52 +546,6 @@ type DescriptorsSerializedCache = {
     dependencies: DependenciesDescriptorSerializedCache;
 };
 
-/**
- * Class with methods to describe elements and dependencies between them.
- */
-declare class Descriptors {
-    private readonly _elementsDescriptor;
-    private readonly _dependenciesDescriptor;
-    /** Creates a new DescriptorsManager instance
-     * @param elementDescriptors The element descriptors.
-     * @param configOptions The configuration options.
-     */
-    constructor(elementDescriptors: ElementDescriptors, configOptions?: ConfigOptions);
-    /**
-     * Serializes the elements and dependencies cache to a plain object.
-     * @returns The serialized elements and dependencies cache.
-     */
-    serializeCache(): DescriptorsSerializedCache;
-    /**
-     * Sets the elements and dependencies cache from a serialized object.
-     * @param serializedCache The serialized elements and dependencies cache.
-     */
-    setCacheFromSerialized(serializedCache: DescriptorsSerializedCache): void;
-    /**
-     * Clears all caches.
-     */
-    clearCache(): void;
-    /**
-     * Describes an element given its file path.
-     * @param filePath The path of the file to describe.
-     * @returns The description of the element.
-     */
-    describeElement(filePath?: string): FileElement;
-    /**
-     * Describes a dependency element given its dependency source and file path.
-     * @param dependencySource The source of the dependency.
-     * @param filePath The path of the file being the dependency, if known.
-     * @returns The description of the dependency element.
-     */
-    describeDependencyElement(dependencySource: string, filePath?: string): DependencyElementDescription;
-    /**
-     * Describes elements in a dependency relationship, and provides additional information about the dependency itself.
-     * @param options The options for describing the elements and the dependency details.
-     * @returns The description of the dependency between the elements.
-     */
-    describeDependency(options: DescribeDependencyOptions): DependencyDescription;
-}
-
 /**
  * Result of matching an element selector against an element.
  */
@@ -592,10 +565,18 @@ type ElementsMatcherSerializedCache = Record<string, ElementSelectorData | null>
  * Serialized cache of dependencies matcher.
  */
 type DependenciesMatcherSerializedCache = Record<string, DependencyMatchResult>;
+/**
+ * Serialized cache of matcher descriptors.
+ */
 type MatcherSerializedCache = {
     descriptors: DescriptorsSerializedCache;
-    elementsMatcher: ElementsMatcherSerializedCache;
-    dependenciesMatcher: DependenciesMatcherSerializedCache;
+};
+/**
+ * Serialized cache of micromatch matcher.
+ */
+type MicromatchSerializedCache = {
+    matchingResults: Record<string, boolean>;
+    captures: Record<string, string[] | null>;
 };
 /**
  * Elements that can return a match when using an element selector.
@@ -784,6 +765,63 @@ type ExternalLibrarySelectors = ExternalLibrariesSelector;
  */
 type ExternalLibrariesSelector = ExternalLibrarySelector | ExternalLibrarySelector[];
 
+/**
+ * Micromatch wrapper class with caching capabilities.
+ */
+declare class Micromatch {
+    /**
+     * Cache for micromatch matching results
+     */
+    private readonly _matchingResultsCache;
+    /**
+     * Cache for micromatch captures
+     */
+    private readonly _capturesCache;
+    /**
+     * Cache for micromatch makeRe results
+     */
+    private readonly _makeReCache;
+    /**
+     * Creates an instance of Micromatch class.
+     * @param cache Whether to use caching or not.
+     */
+    constructor(cache: boolean);
+    /**
+     * Clears all caches.
+     */
+    clearCache(): void;
+    /**
+     * Serializes the current cache state.
+     * @returns The serialized cache data.
+     */
+    serializeCache(): MicromatchSerializedCache;
+    /**
+     * Restores the cache state from serialized data.
+     * @param serializedCache The serialized cache data.
+     */
+    setFromSerialized(serializedCache: MicromatchSerializedCache): void;
+    /**
+     * Optimized micromatch match with caching.
+     * @param value The value to match.
+     * @param pattern The pattern to match against.
+     * @returns True if the value matches the pattern, false otherwise.
+     */
+    isMatch(value: string, pattern: string | string[]): boolean;
+    /**
+     * Optimized micromatch capture with caching.
+     * @param pattern The pattern to match against.
+     * @param target The target string to test.
+     * @returns Captured groups or null if no match.
+     */
+    capture(pattern: string, target: string): string[] | null;
+    /**
+     * Optimized micromatch makeRe with caching.
+     * @param pattern The pattern to convert to RegExp.
+     * @returns The RegExp instance.
+     */
+    makeRe(pattern: string): RegExp;
+}
+
 /**
  * Normalizes an ElementsSelector into an array of ElementSelectorData.
  * @param elementsSelector The elements selector, in any supported format.
@@ -795,22 +833,37 @@ declare function normalizeElementsSelector(elementsSelector: DependencyElementsS
  * Base matcher class to determine if elements or dependencies match a given selector.
  */
 declare class BaseElementsMatcher {
+    /**
+     * Option to use legacy templates with ${} syntax.
+     */
     protected readonly _legacyTemplates: boolean;
+    /**
+     * Micromatch instance for matching.
+     */
+    protected micromatch: Micromatch;
     /**
      * Creates a new BaseElementsMatcher.
      * @param config Configuration options for the matcher.
+     * @param globalCache Global cache instance.
      */
-    constructor(config: ConfigOptionsNormalized);
+    constructor(config: MatchersOptionsNormalized, micromatch: Micromatch);
     /**
      * Converts a template with ${} to Handlebars {{}} templates for backwards compatibility.
      * @param template The template to convert.
      * @returns The converted template.
      */
     private _getBackwardsCompatibleTemplate;
+    /**
+     * Determines if a template contains Handlebars syntax.
+     * @param template The template to check.
+     * @returns True if the template contains Handlebars syntax, false otherwise.
+     */
+    private _isHandlebarsTemplate;
     /**
      * Returns a rendered template using the provided template data.
+     * Optimized version with template caching for better performance.
      * @param template The template to render.
-     * @param extraTemplateData The data to use for replace in the template.
+     * @param templateData The data to use for replace in the template.
      * @returns The rendered template.
      */
     private _getRenderedTemplate;
@@ -823,11 +876,20 @@ declare class BaseElementsMatcher {
     protected getRenderedTemplates(template: MicromatchPattern, templateData: TemplateData): MicromatchPattern;
     /**
      * Returns whether the given value matches the micromatch pattern, converting non-string values to strings.
+     * Optimized version with caching for better performance.
      * @param value The value to check.
      * @param pattern The micromatch pattern to match against.
      * @returns Whether the value matches the pattern.
      */
     protected isMicromatchMatch(value: unknown, pattern: MicromatchPattern): boolean;
+    /**
+     * Returns whether the given value matches the micromatch pattern after rendering it as a template.
+     * @param pattern The micromatch pattern to render and match against.
+     * @param templateData The data to use for rendering the pattern as a template.
+     * @param value The value to check.
+     * @returns Whether the value matches the rendered pattern.
+     */
+    protected isTemplateMicromatchMatch(pattern: MicromatchPattern, templateData: TemplateData, value?: unknown): boolean;
     /**
      * Whether the given element key matches the selector key as booleans.
      * @param param0 The parameters object.
@@ -876,28 +938,15 @@ declare class BaseElementsMatcher {
  * Matcher class to determine if elements match a given selector.
  */
 declare class ElementsMatcher extends BaseElementsMatcher {
-    /**
-     * Cache to store previously described elements.
-     */
-    private readonly _cache;
+    /** Whether the cache is enabled or not */
+    private readonly _cacheIsEnabled;
     /**
      * Creates a new ElementsSelectorMatcher.
+     * @param config Configuration options for the matcher.
+     * @param micromatch Micromatch instance for matching.
+     * @param globalCache Global cache instance.
      */
-    constructor(config: ConfigOptionsNormalized);
-    /**
-     * Serializes the cache to a plain object.
-     * @returns The serialized cache.
-     */
-    serializeCache(): ElementsMatcherSerializedCache;
-    /**
-     * Sets the cache from a serialized object.
-     * @param serializedCache The serialized cache.
-     */
-    setCacheFromSerialized(serializedCache: ElementsMatcherSerializedCache): void;
-    /**
-     * Clears the cache.
-     */
-    clearCache(): void;
+    constructor(config: MatchersOptionsNormalized, micromatch: Micromatch);
     /**
      * Whether the given element type matches the selector type.
      * @param element The element to check.
@@ -1016,32 +1065,18 @@ declare class ElementsMatcher extends BaseElementsMatcher {
  * Matcher class to determine if dependencies match a given dependencies selector.
  */
 declare class DependenciesMatcher extends BaseElementsMatcher {
-    /**
-     * Cache to store previously described dependencies.
-     */
-    private readonly _cache;
     /**
      * Elements matcher to use for matching elements within dependencies.
      */
     private readonly _elementsMatcher;
     /**
      * Creates a new DependenciesMatcher.
+     * @param elementsMatcher Elements matcher to use for matching elements within dependencies.
+     * @param config Configuration options for the matcher.
+     * @param micromatch Micromatch instance for matching.
+     * @param globalCache Global cache instance.
      */
-    constructor(elementsMatcher: ElementsMatcher, config: ConfigOptionsNormalized);
-    /**
-     * Serializes the cache to a plain object.
-     * @returns The serialized cache.
-     */
-    serializeCache(): DependenciesMatcherSerializedCache;
-    /**
-     * Sets the cache from a serialized object.
-     * @param serializedCache The serialized cache.
-     */
-    setCacheFromSerialized(serializedCache: DependenciesMatcherSerializedCache): void;
-    /**
-     * Clears the cache.
-     */
-    clearCache(): void;
+    constructor(elementsMatcher: ElementsMatcher, config: MatchersOptionsNormalized, micromatch: Micromatch);
     /**
      * Normalizes selector into DependencySelectorNormalized format, containing arrays of selectors data.
      * @param selector The dependency selector to normalize.
@@ -1226,9 +1261,12 @@ declare class Matcher {
     /**
      * Constructor for the Matcher class.
      * @param descriptors Element descriptors to use for matching.
+     * @param elementsMatcher Elements matcher instance.
+     * @param dependenciesMatcher Dependencies matcher instance.
      * @param config Configuration options.
+     * @param globalCache Global cache instance.
      */
-    constructor(descriptors: ElementDescriptors, config: ConfigOptionsNormalized);
+    constructor(descriptors: ElementDescriptors, elementsMatcher: ElementsMatcher, dependenciesMatcher: DependenciesMatcher, config: DescriptorOptionsNormalized, micromatch: Micromatch);
     /**
      * Determines if an element matches a given selector.
      * @param filePath The file path of the element
@@ -1268,7 +1306,7 @@ declare class Matcher {
      * @param options Extra options for matching
      * @returns The matching dependency result or null if no match is found
      */
-    private _isDependencySelectorMatching;
+    private _getDependencySelectorMatching;
     /**
      * Determines the selector matching for a dependency or element.
      * @param descriptorOptions The file path or dependency options to describe the element or dependency
@@ -1311,21 +1349,66 @@ declare class Matcher {
      */
     clearCache(): void;
     /**
-     * Serializes the descriptors and elements matchers cache to a plain object.
+     * Serializes the descriptors matchers cache to a plain object.
      * @returns The serialized cache
      */
     serializeCache(): MatcherSerializedCache;
     /**
-     * Sets the descriptors and elements matchers cache from a serialized object.
+     * Sets the descriptors matchers cache from a serialized object.
      * @param serializedCache The serialized cache
      */
     setCacheFromSerialized(serializedCache: {
         descriptors: ReturnType<Descriptors["serializeCache"]>;
-        elementsMatcher: ReturnType<ElementsMatcher["serializeCache"]>;
-        dependenciesMatcher: ReturnType<DependenciesMatcher["serializeCache"]>;
     }): void;
 }
 
+/**
+ * Class with methods to describe elements and dependencies between them.
+ */
+declare class Descriptors {
+    private readonly _elementsDescriptor;
+    private readonly _dependenciesDescriptor;
+    /** Creates a new DescriptorsManager instance
+     * @param elementDescriptors The element descriptors.
+     * @param configOptions The configuration options.
+     * @param micromatch The Micromatch instance.
+     */
+    constructor(elementDescriptors: ElementDescriptors, config: DescriptorOptionsNormalized, micromatch: Micromatch);
+    /**
+     * Serializes the elements and dependencies cache to a plain object.
+     * @returns The serialized elements and dependencies cache.
+     */
+    serializeCache(): DescriptorsSerializedCache;
+    /**
+     * Sets the elements and dependencies cache from a serialized object.
+     * @param serializedCache The serialized elements and dependencies cache.
+     */
+    setCacheFromSerialized(serializedCache: DescriptorsSerializedCache): void;
+    /**
+     * Clears all caches.
+     */
+    clearCache(): void;
+    /**
+     * Describes an element given its file path.
+     * @param filePath The path of the file to describe.
+     * @returns The description of the element.
+     */
+    describeElement(filePath?: string): FileElement;
+    /**
+     * Describes a dependency element given its dependency source and file path.
+     * @param dependencySource The source of the dependency.
+     * @param filePath The path of the file being the dependency, if known.
+     * @returns The description of the dependency element.
+     */
+    describeDependencyElement(dependencySource: string, filePath?: string): DependencyElementDescription;
+    /**
+     * Describes elements in a dependency relationship, and provides additional information about the dependency itself.
+     * @param options The options for describing the elements and the dependency details.
+     * @returns The description of the dependency between the elements.
+     */
+    describeDependency(options: DescribeDependencyOptions): DependencyDescription;
+}
+
 /**
  * Serialized cache for Elements class.
  */
@@ -1336,10 +1419,7 @@ type ElementsSerializedCache = {
         elementDescriptors: ElementDescriptors;
         cache: MatcherSerializedCache;
     }>;
-    /** Cache for ElementsMatcher */
-    elementsMatcher: ElementsMatcherSerializedCache;
-    /** Cache for DependenciesMatcher */
-    dependenciesMatcher: DependenciesMatcherSerializedCache;
+    micromatch: MicromatchSerializedCache;
 };
 
 /**
@@ -1351,10 +1431,9 @@ declare class Elements {
     private readonly _globalConfigOptions;
     /** Cache manager for Matcher instances, unique for each different configuration */
     private readonly _matchersCache;
-    /** Matcher for element selectors */
-    private readonly _elementsMatcher;
-    /** Matcher for dependency selectors */
-    private readonly _dependenciesMatcher;
+    /** Micromatch instances for pattern matching */
+    private readonly _micromatchWithCache;
+    private readonly _micromatchWithoutCache;
     /**
      * Creates a new Elements instance
      * @param configOptions The global configuration options for Elements. Can be overridden when getting a descriptor.
@@ -1378,10 +1457,10 @@ declare class Elements {
      * Gets a Matcher instance for the given configuration options.
      * It uses caching to return the same instance for the same configuration options. If no options are provided, the global configuration options are used.
      * @param elementDescriptors The element descriptors to use.
-     * @param configOptions Optional configuration options to override the global ones.
+     * @param config Optional configuration options to override the global ones.
      * @returns A matcher instance, unique for each different configuration.
      */
-    getMatcher(elementDescriptors: ElementDescriptors, configOptions?: ConfigOptions): Matcher;
+    getMatcher(elementDescriptors: ElementDescriptors, config?: ConfigOptions): Matcher;
 }
 
 /**
@@ -1392,7 +1471,7 @@ declare class ElementsDescriptor {
     /**
      * Cache to store previously described elements.
      */
-    private readonly _elementsCache;
+    private readonly _descriptionsCache;
     /**
      * Cache to store previously described files.
      */
@@ -1405,12 +1484,16 @@ declare class ElementsDescriptor {
      * Element descriptors used by this descriptor.
      */
     private readonly _elementDescriptors;
+    /** Micromatch instance for path matching */
+    private readonly _micromatch;
     /**
      * The configuration options for this descriptor.
      * @param elementDescriptors The element descriptors.
      * @param configOptions The configuration options.
+     * @param globalCache The global cache for various caching needs.
+     * @param micromatch The micromatch instance for path matching.
      */
-    constructor(elementDescriptors: ElementDescriptors, configOptions?: ConfigOptions);
+    constructor(elementDescriptors: ElementDescriptors, configOptions: DescriptorOptionsNormalized, micromatch: Micromatch);
     /**
      * Serializes the elements cache to a plain object.
      * @returns The serialized elements cache.
@@ -1457,7 +1540,7 @@ declare class ElementsDescriptor {
      * @param dependencySource The source of the dependency to check.
      * @returns The base source of the external module. (e.g., for "@scope/package/submodule", it returns "@scope/package")
      */
-    private _getExternalModuleBaseSource;
+    private _getExternalOrCoreModuleBaseSource;
     /**
      * Determines if an element is external based on its file path and dependency source.
      * Files inside "node_modules" are considered external.
@@ -1470,7 +1553,9 @@ declare class ElementsDescriptor {
     private _isExternalDependency;
     /**
      * Determines if a given path is included based on the configuration.
+     * Uses caching for better performance on repeated calls.
      * @param elementPath The element path to check.
+     * @param includeExternal Whether to include external files.
      * @returns True if the path is included, false otherwise.
      */
     private _pathIsIncluded;
@@ -1496,10 +1581,7 @@ declare class ElementsDescriptor {
      */
     private _fileDescriptorMatch;
     /**
-     * Retrieves the description of an element given its path.
-     * It does not identify external files. Files not matching any element are considered unknown.
-     * If a file in node_modules does a match, it is considered local as well.
-     * @param includeExternal Whether to include external files (inside node_modules) in the matching process.
+     * Retrieves the description of a local file given its path.
      * @param elementPath The path of the element to describe.
      * @returns The description of the element.
      */
@@ -1512,12 +1594,12 @@ declare class ElementsDescriptor {
      */
     private _describeFile;
     /**
-     * Describes a dependency element given the file element and dependency source, by completing the file description.
-     * @param element The file element to complete the description for.
+     * Returns an external or core dependency element given its dependency source and file path.
      * @param dependencySource The source of the dependency.
-     * @returns The description of the dependency element.
+     * @param filePath The resolved file path of the dependency, if known.
+     * @returns The external or core dependency element, or null if it is a local dependency.
      */
-    private _describeDependencyElement;
+    private _getExternalOrCoreDependencyElement;
     /**
      * Describes an element given its file path and dependency source, if any.
      * @param filePath The path of the file to describe.
@@ -1552,11 +1634,16 @@ declare class DependenciesDescriptor {
      * Elements descriptor instance.
      */
     private readonly _elementsDescriptor;
+    /**
+     * Configuration options.
+     */
+    private readonly _config;
     /**
      * Creates a new DependenciesDescriptor instance.
      * @param elementsDescriptor The elements descriptor instance.
+     * @param config The configuration options.
      */
-    constructor(elementsDescriptor: ElementsDescriptor);
+    constructor(elementsDescriptor: ElementsDescriptor, config: DescriptorOptionsNormalized);
     /**
      * Serializes the elements cache to a plain object.
      * @returns The serialized elements cache.
@@ -1635,6 +1722,9 @@ declare class DependenciesDescriptor {
     describeDependency({ from, to, source, kind, nodeKind, specifiers, }: DescribeDependencyOptions): DependencyDescription;
 }
 
+type ObjectCacheKey = Record<string, unknown>;
+type NotUndefined = object | string | number | boolean | NotUndefined[];
+
 /**
  * Generic cache manager class. Enables caching of values based on complex keys.
  */
@@ -1647,36 +1737,36 @@ declare class CacheManager<CacheKey extends NotUndefined, CachedValue> {
      * Creates a new CacheManager instance
      */
     constructor();
+    /**
+     * Generates a string key from the given cache key. Has to be implemented for non-string keys.
+     * @param key The cache key to generate from
+     * @returns The generated string key
+     */
+    protected generateKey(key: CacheKey): string;
     /**
      * Generates a hashed key for the given cache key
      * @param key The cache key to hash
      * @returns The hashed key as a string
      */
-    private _getHashedKey;
+    getKey(key: CacheKey): string;
     /**
-     * Retrieves a value from the cache based on the given key
-     * @param key The cache key to retrieve
+     * Retrieves a value from the cache based on the given hashed key
+     * @param hashedKey The hashed key to retrieve
      * @returns The cached value or undefined if not found
      */
-    get(key: CacheKey): CachedValue | undefined;
+    get(hashedKey: string): CachedValue | undefined;
     /**
-     * Stores a value in the cache
-     * @param key The cache key to store
+     * Stores a value in the cache with a given hashed key
+     * @param hashedKey The hashed key to store
      * @param value The value to cache
      */
-    set(key: CacheKey, value: CachedValue): void;
-    /**
-     * Restores a value in the cache from a given already hashed key
-     * @param key The hashed key to restore
-     * @param value The value to restore
-     */
-    restore(key: string, value: CachedValue): void;
+    set(hashedKey: string, value: CachedValue): void;
     /**
-     * Checks if a value exists in the cache
-     * @param key The cache key to check
+     * Checks if a value exists in the cache based on the given hashed key
+     * @param hashedKey The hashed key to check
      * @returns True if the value exists, false otherwise
      */
-    has(key: CacheKey): boolean;
+    has(hashedKey: string): boolean;
     /**
      * Retrieves all cached values
      * @returns A map of all cached values
@@ -1698,4 +1788,4 @@ declare class CacheManager<CacheKey extends NotUndefined, CachedValue> {
     setFromSerialized(serializedCache: Record<string, CachedValue>): void;
 }
 
-export { type BaseDependencyElement, type BaseElement, type BaseElementDescriptor, type BaseElementSelector, type BaseElementSelectorData, type BaseElementSelectorWithOptions, type BaseElementsSelector, CacheManager, type CapturedValues, type CapturedValuesSelector, type ConfigOptions, type ConfigOptionsNormalized, type CoreDependencyElement, DEPENDENCY_KINDS_MAP, DEPENDENCY_KIND_TYPE, DEPENDENCY_KIND_VALUE, DEPENDENCY_RELATIONSHIPS_INVERTED_MAP, DEPENDENCY_RELATIONSHIPS_MAP, DependenciesDescriptor, type DependenciesDescriptorSerializedCache, DependenciesMatcher, type DependenciesMatcherSerializedCache, type DependencyDescription, type DependencyElementDescription, type DependencyElementSelector, type DependencyElementSelectorData, type DependencyElementSelectorWithOptions, type DependencyElementsSelector, type DependencyKind, type DependencyMatchResult, type DependencyRelationship, type DependencySelector, type DependencySelectorNormalized, type DescribeDependencyOptions, Descriptors, type DescriptorsSerializedCache, ELEMENT_DESCRIPTOR_MODES_MAP, ELEMENT_ORIGINS_MAP, type ElementDescription, type ElementDescriptor, type ElementDescriptorMode, type ElementDescriptorPattern, type ElementDescriptorWithCategory, type ElementDescriptorWithType, type ElementDescriptorWithTypeAndCategory, type ElementDescriptors, type ElementOrigin, type ElementParent, type ElementSelector, type ElementSelectorData, type ElementSelectorWithOptions, type ElementSelectors, Elements, type ElementsDependencyInfo, ElementsDescriptor, type ElementsDescriptorSerializedCache, ElementsMatcher, type ElementsMatcherSerializedCache, type ElementsSelector, type ElementsSerializedCache, type ExternalDependencyElement, type ExternalLibrariesSelector, type ExternalLibrarySelector, type ExternalLibrarySelectorOptions, type ExternalLibrarySelectorWithOptions, type ExternalLibrarySelectors, type FileElement, type IgnoredDependencyElement, type IgnoredElement, type LocalDependencyElement, type LocalDependencyElementKnown, type LocalDependencyElementUnknown, type LocalElementKnown, type LocalElementUnknown, Matcher, type MatcherOptions, type MatcherOptionsDependencySelectorsGlobals, type MatcherSerializedCache, type MicromatchPattern, type SelectableElement, type SimpleElementSelectorByType, type TemplateData, isBaseElement, isBaseElementDescriptor, isBaseElementSelectorData, isCapturedValuesSelector, isCoreDependencyElement, isDependencyDescription, isDependencyElementDescription, isDependencyKind, isDependencyRelationship, isDependencyRelationshipDescription, isDependencySelector, isElementDescription, isElementDescriptor, isElementDescriptorMode, isElementDescriptorPattern, isElementDescriptorWithCategory, isElementDescriptorWithType, isElementSelector, isElementSelectorData, isElementSelectorWithLegacyOptions, isElementsDependencyInfo, isElementsSelector, isExternalDependencyElement, isExternalLibrariesSelector, isExternalLibrarySelector, isExternalLibrarySelectorOptions, isExternalLibrarySelectorOptionsWithPath, isExternalLibrarySelectorOptionsWithSpecifiers, isExternalLibrarySelectorWithOptions, isIgnoredElement, isInternalDependency, isKnownLocalElement, isLocalDependencyElement, isLocalElement, isSimpleElementSelectorByType, isUnknownLocalElement, normalizeElementsSelector };
+export { type BaseDependencyElement, type BaseElement, type BaseElementDescriptor, type BaseElementSelector, type BaseElementSelectorData, type BaseElementSelectorWithOptions, type BaseElementsSelector, CacheManager, type CapturedValues, type CapturedValuesSelector, type ConfigOptions, type ConfigOptionsNormalized, type CoreDependencyElement, DEPENDENCY_KINDS_MAP, DEPENDENCY_KIND_TYPE, DEPENDENCY_KIND_VALUE, DEPENDENCY_RELATIONSHIPS_INVERTED_MAP, DEPENDENCY_RELATIONSHIPS_MAP, DependenciesDescriptor, type DependenciesDescriptorSerializedCache, DependenciesMatcher, type DependenciesMatcherSerializedCache, type DependencyDescription, type DependencyElementDescription, type DependencyElementSelector, type DependencyElementSelectorData, type DependencyElementSelectorWithOptions, type DependencyElementsSelector, type DependencyKind, type DependencyMatchResult, type DependencyRelationship, type DependencySelector, type DependencySelectorNormalized, type DescribeDependencyOptions, type DescriptionsSerializedCache, type DescriptorOptionsNormalized, Descriptors, type DescriptorsSerializedCache, ELEMENT_DESCRIPTOR_MODES_MAP, ELEMENT_ORIGINS_MAP, type ElementDescription, type ElementDescriptor, type ElementDescriptorMode, type ElementDescriptorPattern, type ElementDescriptorWithCategory, type ElementDescriptorWithType, type ElementDescriptorWithTypeAndCategory, type ElementDescriptors, type ElementOrigin, type ElementParent, type ElementSelector, type ElementSelectorData, type ElementSelectorWithOptions, type ElementSelectors, Elements, type ElementsDependencyInfo, ElementsDescriptor, type ElementsDescriptorSerializedCache, ElementsMatcher, type ElementsMatcherSerializedCache, type ElementsSelector, type ElementsSerializedCache, type ExternalDependencyElement, type ExternalLibrariesSelector, type ExternalLibrarySelector, type ExternalLibrarySelectorOptions, type ExternalLibrarySelectorWithOptions, type ExternalLibrarySelectors, type FileElement, type FileElementsSerializedCache, type IgnoredDependencyElement, type IgnoredElement, type LocalDependencyElement, type LocalDependencyElementKnown, type LocalDependencyElementUnknown, type LocalElementKnown, type LocalElementUnknown, Matcher, type MatcherOptions, type MatcherOptionsDependencySelectorsGlobals, type MatcherSerializedCache, type MatchersOptionsNormalized, type MicromatchPattern, type MicromatchSerializedCache, type NotUndefined, type ObjectCacheKey, type SelectableElement, type SimpleElementSelectorByType, type TemplateData, isBaseElement, isBaseElementDescriptor, isBaseElementSelectorData, isCapturedValuesSelector, isCoreDependencyElement, isDependencyDescription, isDependencyElementDescription, isDependencyKind, isDependencyRelationship, isDependencyRelationshipDescription, isDependencySelector, isElementDescription, isElementDescriptor, isElementDescriptorMode, isElementDescriptorPattern, isElementDescriptorWithCategory, isElementDescriptorWithType, isElementSelector, isElementSelectorData, isElementSelectorWithLegacyOptions, isElementsDependencyInfo, isElementsSelector, isExternalDependencyElement, isExternalLibrariesSelector, isExternalLibrarySelector, isExternalLibrarySelectorOptions, isExternalLibrarySelectorOptionsWithPath, isExternalLibrarySelectorOptionsWithSpecifiers, isExternalLibrarySelectorWithOptions, isIgnoredElement, isInternalDependency, isKnownLocalElement, isLocalDependencyElement, isLocalElement, isSimpleElementSelectorByType, isUnknownLocalElement, normalizeElementsSelector };