inray 0.0.2 → 0.0.3

package/dist/caching/src/hashing/providers.js

@@ -0,0 +1,163 @@
+/**
+ * Original library: hashery (v1.5.1)
+ * - Copyright (c) 2025 Jared Wray
+ *
+ * Modified and integrated in "Inray":
+ * - Evgeniy Bushin
+ */
+/***/
+/**
+ * Manages a collection of hash providers for the Hashery system.
+ * Provides methods to add, remove, and load multiple hash providers.
+ */
+export class HashProviders {
+    _providers = new Map();
+    _getFuzzy = true;
+    /**
+     * Creates a new HashProviders instance.
+     * @param options - Optional configuration including initial providers to load
+     * @example
+     * ```ts
+     * const providers = new HashProviders({
+     *   providers: [{ name: 'custom', toHash: async (data) => '...' }]
+     * });
+     * ```
+     */
+    constructor(options) {
+        if (options?.providers) {
+            this.loadProviders(options?.providers);
+        }
+        if (options?.getFuzzy !== undefined) {
+            this._getFuzzy = Boolean(options?.getFuzzy);
+        }
+    }
+    /**
+     * Loads multiple hash providers at once.
+     * Each provider is added to the internal map using its name as the key.
+     * @param providers - Array of HashProvider objects to load
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.loadProviders([
+     *   { name: 'md5', toHash: async (data) => '...' },
+     *   { name: 'sha1', toHash: async (data) => '...' }
+     * ]);
+     * ```
+     */
+    loadProviders(providers) {
+        for (const provider of providers) {
+            this._providers.set(provider.name, provider);
+        }
+    }
+    /**
+     * Gets the internal Map of all registered hash providers.
+     * @returns Map of provider names to HashProvider objects
+     */
+    get providers() {
+        return this._providers;
+    }
+    /**
+     * Sets the internal Map of hash providers, replacing all existing providers.
+     * @param providers - Map of provider names to HashProvider objects
+     */
+    set providers(providers) {
+        this._providers = providers;
+    }
+    /**
+     * Gets an array of all provider names.
+     * @returns Array of provider names
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({ name: 'sha256', toHash: async (data) => '...' });
+     * providers.add({ name: 'md5', toHash: async (data) => '...' });
+     * console.log(providers.names); // ['sha256', 'md5']
+     * ```
+     */
+    get names() {
+        return Array.from(this._providers.keys());
+    }
+    /**
+     * Gets a hash provider by name with optional fuzzy matching.
+     *
+     * Fuzzy matching (enabled by default) attempts to find providers by:
+     * 1. Exact match (after trimming whitespace)
+     * 2. Case-insensitive match (lowercase)
+     * 3. Dash-removed match (e.g., "SHA-256" matches "sha256")
+     *
+     * @param name - The name of the provider to retrieve
+     * @param options - Optional configuration for the get operation
+     * @param options.fuzzy - Enable/disable fuzzy matching (overrides constructor setting)
+     * @returns The HashProvider if found, undefined otherwise
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({ name: 'sha256', toHash: async (data) => '...' });
+     *
+     * // Exact match
+     * const provider = providers.get('sha256');
+     *
+     * // Fuzzy match (case-insensitive)
+     * const provider2 = providers.get('SHA256');
+     *
+     * // Fuzzy match (with dash)
+     * const provider3 = providers.get('SHA-256');
+     *
+     * // Disable fuzzy matching
+     * const provider4 = providers.get('SHA256', { fuzzy: false }); // returns undefined
+     * ```
+     */
+    get(name, options) {
+        // set the options
+        const getFuzzy = options?.fuzzy ?? this._getFuzzy;
+        // do the trim
+        name = name.trim();
+        let result = this._providers.get(name);
+        // try with lower case
+        if (result === undefined && getFuzzy === true) {
+            name = name.toLowerCase();
+            result = this._providers.get(name);
+        }
+        // try removing dash
+        if (result === undefined && getFuzzy === true) {
+            name = name.replaceAll('-', '');
+            result = this._providers.get(name);
+        }
+        return result;
+    }
+    /**
+     * Adds a single hash provider to the collection.
+     * If a provider with the same name already exists, it will be replaced.
+     * @param provider - The HashProvider object to add
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({
+     *   name: 'custom-hash',
+     *   toHash: async (data) => {
+     *     // Custom hashing logic
+     *     return 'hash-result';
+     *   }
+     * });
+     * ```
+     */
+    add(provider) {
+        this._providers.set(provider.name, provider);
+    }
+    /**
+     * Removes a hash provider from the collection by name.
+     * @param name - The name of the provider to remove
+     * @returns true if the provider was found and removed, false otherwise
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({ name: 'custom', toHash: async (data) => '...' });
+     * const removed = providers.remove('custom'); // returns true
+     * const removed2 = providers.remove('nonexistent'); // returns false
+     * ```
+     */
+    remove(name) {
+        return this._providers.delete(name);
+    }
+}
+//# sourceMappingURL=providers.js.map

package/dist/caching/src/hashing/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.js","sourceRoot":"","sources":["../../../../src/caching/src/hashing/providers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,KAAK;AAIL;;;GAGG;AACH,MAAM,OAAO,aAAa;IAChB,UAAU,GAA8B,IAAI,GAAG,EAAE,CAAC;IAClD,SAAS,GAAG,IAAI,CAAC;IAEzB;;;;;;;;;OASG;IACH,YAAY,OAA8B;QACxC,IAAI,OAAO,EAAE,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACzC,CAAC;QAED,IAAI,OAAO,EAAE,QAAQ,KAAK,SAAS,EAAE,CAAC;YACpC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,aAAa,CAAC,SAA8B;QACjD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,IAAW,SAAS,CAAC,SAAoC;QACvD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;OAUG;IACH,IAAW,KAAK;QACd,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACI,GAAG,CAAC,IAAY,EAAE,OAAiC;QACxD,kBAAkB;QAClB,MAAM,QAAQ,GAAG,OAAO,EAAE,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC;QAElD,cAAc;QACd,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAEnB,IAAI,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEvC,sBAAsB;QACtB,IAAI,MAAM,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC9C,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1B,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QAED,oBAAoB;QACpB,IAAI,MAAM,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC9C,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YAChC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,GAAG,CAAC,QAAsB;QAC/B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,IAAY;QACxB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;CACF"}

package/dist/caching/src/hashing/types.d.ts

@@ -0,0 +1,340 @@
+/**
+ * Original library: hashery (v1.5.1)
+ * - Copyright (c) 2025 Jared Wray
+ *
+ * Modified and integrated in "Inray":
+ * - Evgeniy Bushin
+ */
+/***/
+import type { HookifiedOptions } from './hooks/index.ts';
+import type { CacheOptions } from './cache.ts';
+/**
+ * Configuration options for Hashery instances.
+ * Extends HookifiedOptions to include parse and stringify functionality.
+ */
+export type HasheryOptions = {
+    /**
+     * Custom parse function to deserialize string data.
+     * Defaults to JSON.parse if not provided.
+     * @example
+     * ```ts
+     * import superjson from 'superjson';
+     *
+     * const hashery = new Hashery({
+     *   parse: (data) => superjson.parse(data)
+     * });
+     * ```
+     */
+    parse?: ParseFn;
+    /**
+     * Custom stringify function to serialize data to string format.
+     * Defaults to JSON.stringify if not provided.
+     * @example
+     * ```ts
+     * import superjson from 'superjson';
+     *
+     * const hashery = new Hashery({
+     *   stringify: (data) => superjson.stringify(data)
+     * });
+     * ```
+     */
+    stringify?: StringifyFn;
+    /**
+     * Array of hash providers to add to base providers
+     * Providers implement the HashProvider interface and enable custom hashing algorithms.
+     * @example
+     * ```ts
+     * const customProvider = {
+     *   name: 'custom-hash',
+     *   toHash: async (data) => {
+     *     // Custom hash implementation
+     *     return 'hash-value';
+     *   }
+     * };
+     *
+     * const hashery = new Hashery({
+     *   providers: [customProvider]
+     * });
+     * ```
+     */
+    providers?: Array<HashProvider>;
+    /**
+     * Whether to include base WebCrypto providers (SHA-256, SHA-384, SHA-512).
+     * Defaults to true.
+     * @example
+     * ```ts
+     * // Create instance without base providers
+     * const hashery = new Hashery({
+     *   includeBase: false,
+     *   providers: [customProvider]
+     * });
+     * ```
+     */
+    includeBase?: boolean;
+    /**
+     * Default hash algorithm to use when none is specified.
+     * Defaults to 'SHA-256'.
+     * @example
+     * ```ts
+     * const hashery = new Hashery({
+     *   defaultAlgorithm: 'SHA-512'
+     * });
+     *
+     * // This will use SHA-512 instead of SHA-256
+     * const hash = await hashery.toHash({ data: 'example' });
+     * ```
+     */
+    defaultAlgorithm?: HashAlgorithm | (string & {});
+    /**
+     * Default synchronous hash algorithm to use when none is specified.
+     * Defaults to 'djb2'.
+     * @example
+     * ```ts
+     * const hashery = new Hashery({
+     *   defaultAlgorithmSync: 'fnv1'
+     * });
+     *
+     * // This will use fnv1 for synchronous operations by default
+     * ```
+     */
+    defaultAlgorithmSync?: HashAlgorithm | (string & {});
+    /**
+     * Cache configuration options.
+     * Pass { enabled: true } to enable caching of hash results.
+     * @example
+     * ```ts
+     * const hashery = new Hashery({
+     *   cache: { enabled: true, maxSize: 500 }
+     * });
+     *
+     * // Hashes will be cached and reused for identical inputs
+     * ```
+     */
+    cache?: CacheOptions;
+} & HookifiedOptions;
+/**
+ * Options for the toHash method.
+ * @example
+ * ```ts
+ * const hashery = new Hashery();
+ *
+ * // Using a specific algorithm
+ * const hash = await hashery.toHash({ data: 'example' }, { algorithm: 'SHA-512' });
+ *
+ * // Truncating the hash output
+ * const shortHash = await hashery.toHash(
+ *   { data: 'example' },
+ *   { algorithm: 'SHA-256', maxLength: 16 }
+ * );
+ * ```
+ */
+export type HasheryToHashOptions = {
+    /**
+     * The hash algorithm to use.
+     * Defaults to 'SHA-256' if not specified.
+     * Supported algorithms include: 'SHA-256', 'SHA-384', 'SHA-512', 'djb2', 'fnv1', 'murmur', 'crc32'
+     */
+    algorithm?: HashAlgorithm | (string & {});
+    /**
+     * Maximum length for the hash output.
+     * If specified, the hash will be truncated to this length.
+     * @example
+     * ```ts
+     * // Get a 16-character hash instead of the full 64-character SHA-256 hash
+     * const hash = await hashery.toHash({ data: 'example' }, { maxLength: 16 });
+     * ```
+     */
+    maxLength?: number;
+};
+/**
+ * Options for the toNumber method.
+ * @example
+ * ```ts
+ * const hashery = new Hashery();
+ *
+ * // Using default range (0-100)
+ * const num = await hashery.toNumber({ user: 'john' });
+ *
+ * // Using custom range
+ * const slot = await hashery.toNumber({ user: 'john' }, { min: 0, max: 9 });
+ *
+ * // Using different algorithm
+ * const num512 = await hashery.toNumber(
+ *   { user: 'john' },
+ *   { min: 0, max: 255, algorithm: 'SHA-512' }
+ * );
+ * ```
+ */
+export type HasheryToNumberOptions = {
+    /**
+     * The hash algorithm to use.
+     * Defaults to 'SHA-256' if not specified.
+     * Supported algorithms include: 'SHA-256', 'SHA-384', 'SHA-512', 'djb2', 'fnv1', 'murmur', 'crc32'
+     */
+    algorithm?: HashAlgorithm | (string & {});
+    /**
+     * The minimum value of the range (inclusive).
+     * Defaults to 0 if not specified.
+     * @example
+     * ```ts
+     * // Generate number between 1 and 100
+     * const num = await hashery.toNumber({ data: 'example' }, { min: 1, max: 100 });
+     * ```
+     */
+    min?: number;
+    /**
+     * The maximum value of the range (inclusive).
+     * Defaults to 100 if not specified.
+     * @example
+     * ```ts
+     * // Generate number between 0 and 1000
+     * const num = await hashery.toNumber({ data: 'example' }, { min: 0, max: 1000 });
+     * ```
+     */
+    max?: number;
+    /**
+     * Number of characters from the hash to use for conversion.
+     * Defaults to 16 if not specified.
+     * This provides good distribution while avoiding precision issues with JavaScript numbers.
+     * @example
+     * ```ts
+     * // Use more hash characters for better distribution
+     * const num = await hashery.toNumber({ data: 'example' }, { hashLength: 32 });
+     * ```
+     */
+    hashLength?: number;
+};
+/**
+ * Options for the toHashSync method.
+ * @example
+ * ```ts
+ * const hashery = new Hashery();
+ *
+ * // Using a specific algorithm
+ * const hash = hashery.toHashSync({ data: 'example' }, { algorithm: 'fnv1' });
+ *
+ * // Truncating the hash output
+ * const shortHash = hashery.toHashSync(
+ *   { data: 'example' },
+ *   { algorithm: 'djb2', maxLength: 16 }
+ * );
+ * ```
+ */
+export type HasheryToHashSyncOptions = {
+    /**
+     * The hash algorithm to use.
+     * Defaults to 'djb2' if not specified.
+     * Supported synchronous algorithms include: 'djb2', 'fnv1', 'murmur', 'crc32'
+     * Note: WebCrypto algorithms (SHA-256, SHA-384, SHA-512) are not supported in sync mode.
+     */
+    algorithm?: HashAlgorithm | (string & {});
+    /**
+     * Maximum length for the hash output.
+     * If specified, the hash will be truncated to this length.
+     * @example
+     * ```ts
+     * // Get a 16-character hash
+     * const hash = hashery.toHashSync({ data: 'example' }, { maxLength: 16 });
+     * ```
+     */
+    maxLength?: number;
+};
+/**
+ * Options for the toNumberSync method.
+ * @example
+ * ```ts
+ * const hashery = new Hashery();
+ *
+ * // Using default range (0-100)
+ * const num = hashery.toNumberSync({ user: 'john' });
+ *
+ * // Using custom range
+ * const slot = hashery.toNumberSync({ user: 'john' }, { min: 0, max: 9 });
+ *
+ * // Using different algorithm
+ * const num = hashery.toNumberSync(
+ *   { user: 'john' },
+ *   { min: 0, max: 255, algorithm: 'fnv1' }
+ * );
+ * ```
+ */
+export type HasheryToNumberSyncOptions = {
+    /**
+     * The hash algorithm to use.
+     * Defaults to 'djb2' if not specified.
+     * Supported synchronous algorithms include: 'djb2', 'fnv1', 'murmur', 'crc32'
+     * Note: WebCrypto algorithms (SHA-256, SHA-384, SHA-512) are not supported in sync mode.
+     */
+    algorithm?: HashAlgorithm | (string & {});
+    /**
+     * The minimum value of the range (inclusive).
+     * Defaults to 0 if not specified.
+     * @example
+     * ```ts
+     * // Generate number between 1 and 100
+     * const num = hashery.toNumberSync({ data: 'example' }, { min: 1, max: 100 });
+     * ```
+     */
+    min?: number;
+    /**
+     * The maximum value of the range (inclusive).
+     * Defaults to 100 if not specified.
+     * @example
+     * ```ts
+     * // Generate number between 0 and 1000
+     * const num = hashery.toNumberSync({ data: 'example' }, { min: 0, max: 1000 });
+     * ```
+     */
+    max?: number;
+    /**
+     * Number of characters from the hash to use for conversion.
+     * Defaults to 16 if not specified.
+     * This provides good distribution while avoiding precision issues with JavaScript numbers.
+     * @example
+     * ```ts
+     * // Use more hash characters for better distribution
+     * const num = hashery.toNumberSync({ data: 'example' }, { hashLength: 32 });
+     * ```
+     */
+    hashLength?: number;
+};
+/**
+ * Function type for serializing data to a string.
+ * @param data - The data to stringify
+ * @returns The stringified representation
+ */
+export type StringifyFn = (data: unknown) => string;
+/**
+ * Function type for parsing string data.
+ * @param data - The string data to parse
+ * @returns The parsed data
+ */
+export type ParseFn = (data: string) => unknown;
+/**
+ * Supported hash algorithms for the Web Crypto API.
+ * - SHA-256: Recommended algorithm (256-bit) - good balance of security and performance
+ * - SHA-384: High security algorithm (384-bit)
+ * - SHA-512: Highest security algorithm (512-bit)
+ */
+export type WebCryptoHashAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512';
+/**
+ * All built-in hash algorithm names supported by Hashery.
+ * Includes both WebCrypto (async-only) and non-cryptographic (sync & async) algorithms.
+ */
+export type HashAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512' | 'djb2' | 'fnv1' | 'murmur' | 'crc32';
+export type HashProvider = {
+    name: string;
+    toHash(data: BufferSource): Promise<string>;
+    toHashSync?(data: BufferSource): string;
+};
+export type HashProvidersOptions = {
+    providers?: Array<HashProvider>;
+    getFuzzy?: boolean;
+};
+export type HashProvidersGetOptions = {
+    fuzzy?: boolean;
+};
+export type HasheryLoadProviderOptions = {
+    includeBase?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/caching/src/hashing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/caching/src/hashing/types.ts"],"names":[],"mappings":"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"}

package/dist/caching/src/hashing/types.js

@@ -0,0 +1,10 @@
+/**
+ * Original library: hashery (v1.5.1)
+ * - Copyright (c) 2025 Jared Wray
+ *
+ * Modified and integrated in "Inray":
+ * - Evgeniy Bushin
+ */
+/***/
+export {};
+//# sourceMappingURL=types.js.map

package/dist/caching/src/hashing/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/caching/src/hashing/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,KAAK"}

package/dist/caching/src/keyValue/capabilities.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Original library: keyv (v5.6.0)
+ * - Copyright (c) 2017-2021 Luke Childs
+ * - Copyright (c) 2021-2022 Jared Wray
+ *
+ * Modified and integrated in "Inray":
+ * - Evgeniy Bushin
+ */
+/***/
+export type IsKeyvResult = {
+    keyv: boolean;
+    get: boolean;
+    set: boolean;
+    delete: boolean;
+    clear: boolean;
+    has: boolean;
+    getMany: boolean;
+    setMany: boolean;
+    deleteMany: boolean;
+    hasMany: boolean;
+    disconnect: boolean;
+    getRaw: boolean;
+    getManyRaw: boolean;
+    hooks: boolean;
+    stats: boolean;
+    iterator: boolean;
+};
+export type IsKeyvStorageResult = {
+    keyvStorage: boolean;
+    get: boolean;
+    set: boolean;
+    delete: boolean;
+    clear: boolean;
+    has: boolean;
+    getMany: boolean;
+    setMany: boolean;
+    deleteMany: boolean;
+    hasMany: boolean;
+    disconnect: boolean;
+    iterator: boolean;
+    namespace: boolean;
+};
+export type IsKeyvCompressionResult = {
+    keyvCompression: boolean;
+    compress: boolean;
+    decompress: boolean;
+};
+export type IsKeyvSerializationResult = {
+    keyvSerialization: boolean;
+    stringify: boolean;
+    parse: boolean;
+};
+export type IsKeyvEncryptionResult = {
+    keyvEncryption: boolean;
+    encrypt: boolean;
+    decrypt: boolean;
+};
+/**
+ * Check if an object is a Keyv instance or has Keyv-like capabilities
+ * @param obj - The object to check
+ * @returns An object with boolean properties for each Keyv method/property
+ * @example
+ * ```typescript
+ * import { isKeyv } from 'keyv';
+ *
+ * isKeyv(new Map());
+ * // { keyv: false, get: true, set: true, delete: true, clear: true, has: true,
+ * //   getMany: false, setMany: false, deleteMany: false, hasMany: false,
+ * //   disconnect: false, getRaw: false, getManyRaw: false, hooks: false,
+ * //   stats: false, iterator: false }
+ *
+ * isKeyv(new Keyv());
+ * // { keyv: true, get: true, set: true, delete: true, clear: true, has: true,
+ * //   getMany: true, setMany: true, deleteMany: true, hasMany: true,
+ * //   disconnect: true, getRaw: true, getManyRaw: true, hooks: true,
+ * //   stats: true, iterator: false }
+ * ```
+ */
+export declare function isKeyv(obj: unknown): IsKeyvResult;
+/**
+ * Check if an object is a Keyv storage adapter or has storage adapter-like capabilities
+ * @param obj - The object to check
+ * @returns An object with boolean properties for each storage adapter method/property
+ * @example
+ * ```typescript
+ * import { isKeyvStorage } from 'keyv';
+ *
+ * isKeyvStorage(new Map());
+ * // { keyvStorage: false, get: true, set: true, delete: true, clear: true, has: true,
+ * //   getMany: false, setMany: false, deleteMany: false, hasMany: false,
+ * //   disconnect: false, iterator: false, namespace: false }
+ *
+ * const adapter = new KeyvRedis();
+ * isKeyvStorage(adapter);
+ * // { keyvStorage: true, get: true, set: true, delete: true, clear: true, has: true,
+ * //   getMany: true, setMany: true, deleteMany: true, hasMany: true,
+ * //   disconnect: true, iterator: true, namespace: true }
+ * ```
+ */
+export declare function isKeyvStorage(obj: unknown): IsKeyvStorageResult;
+/**
+ * Check if an object is a Keyv compression adapter or has compression capabilities
+ * @param obj - The object to check
+ * @returns An object with boolean properties for each compression method
+ * @example
+ * ```typescript
+ * import { isKeyvCompression } from 'keyv';
+ *
+ * const gzip = {
+ *   compress: (data) => compressSync(data),
+ *   decompress: (data) => decompressSync(data)
+ * };
+ * isKeyvCompression(gzip);
+ * // { keyvCompression: true, compress: true, decompress: true }
+ *
+ * isKeyvCompression({});
+ * // { keyvCompression: false, compress: false, decompress: false }
+ * ```
+ */
+export declare function isKeyvCompression(obj: unknown): IsKeyvCompressionResult;
+/**
+ * Check if an object is a Keyv serialization adapter or has serialization capabilities
+ * @param obj - The object to check
+ * @returns An object with boolean properties for each serialization method
+ * @example
+ * ```typescript
+ * import { isKeyvSerialization } from 'keyv';
+ *
+ * const json = {
+ *   stringify: (obj) => JSON.stringify(obj),
+ *   parse: (str) => JSON.parse(str)
+ * };
+ * isKeyvSerialization(json);
+ * // { keyvSerialization: true, stringify: true, parse: true }
+ *
+ * isKeyvSerialization({});
+ * // { keyvSerialization: false, stringify: false, parse: false }
+ * ```
+ */
+export declare function isKeyvSerialization(obj: unknown): IsKeyvSerializationResult;
+/**
+ * Check if an object is a Keyv encryption adapter or has encryption capabilities
+ * @param obj - The object to check
+ * @returns An object with boolean properties for each encryption method
+ * @example
+ * ```typescript
+ * import { isKeyvEncryption } from 'keyv';
+ *
+ * const aes = {
+ *   encrypt: (data) => encryptAES(data),
+ *   decrypt: (data) => decryptAES(data)
+ * };
+ * isKeyvEncryption(aes);
+ * // { keyvEncryption: true, encrypt: true, decrypt: true }
+ *
+ * isKeyvEncryption({});
+ * // { keyvEncryption: false, encrypt: false, decrypt: false }
+ * ```
+ */
+export declare function isKeyvEncryption(obj: unknown): IsKeyvEncryptionResult;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/caching/src/keyValue/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/caching/src/keyValue/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,KAAK;AAEL,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,OAAO,CAAC;IACrB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAoFjD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,mBAAmB,CA0E/D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,uBAAuB,CA8BvE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,yBAAyB,CA8B3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,CA8BrE"}