rust-node-cache 0.2.0 → 0.2.1

package/README.md

@@ -44,6 +44,25 @@ Works with both **ESM** and **CommonJS**, and requires **Node.js 18+**.
 
 ---
 
+## Supported platforms
+
+Prebuilt binaries are published for:
+
+| OS      | Architecture          | Triple                       |
+| ------- | --------------------- | ---------------------------- |
+| macOS   | arm64                 | `aarch64-apple-darwin`       |
+| macOS   | x64                   | `x86_64-apple-darwin`        |
+| Linux   | x64 (glibc)           | `x86_64-unknown-linux-gnu`   |
+| Linux   | arm64 (glibc)         | `aarch64-unknown-linux-gnu`  |
+| Linux   | x64 (musl, Alpine)    | `x86_64-unknown-linux-musl`  |
+| Linux   | arm64 (musl, Alpine)  | `aarch64-unknown-linux-musl` |
+| Windows | x64                   | `x86_64-pc-windows-msvc`     |
+
+Every release is installed from the packed tarball and exercised on each of these platforms
+in CI before it is published.
+
+---
+
 ## Quick Start
 
 ```ts

package/binding.d.ts

@@ -4,32 +4,32 @@
 /* auto-generated by NAPI-RS */
 
 /**
- * Opções do construtor:
+ * Constructor options:
  * `new Cache({ maxSize, evictionPolicy, cleanupIntervalSeconds })`.
  */
 export interface CacheOptions {
   /**
-   * Limite opcional de chaves. Comportamento ao atingir depende de
-   * `evictionPolicy`.
+   * Optional limit on the number of keys. What happens when it is reached
+   * depends on `evictionPolicy`.
    */
   maxSize?: number
   /**
-   * `"reject"` (padrão) — `set` de chave nova retorna `false` quando cheio;
-   * `"lru"` — remove a entrada menos recentemente usada e prossegue.
+   * `"reject"` (default) — `set` of a new key returns `false` when full;
+   * `"lru"` — removes the least recently used entry and goes on.
    */
   evictionPolicy?: string
   /**
-   * Se definido (> 0), liga uma thread que varre entradas expiradas a cada
-   * N segundos (expiração em background, além da lazy).
+   * When set (> 0), starts a thread that sweeps expired entries every N
+   * seconds (background expiration, on top of the lazy one).
    */
   cleanupIntervalSeconds?: number
 }
-/** Opções por escrita: `cache.set(key, value, { ttlSeconds })`. */
+/** Per-write options: `cache.set(key, value, { ttlSeconds })`. */
 export interface SetOptions {
-  /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */
+  /** Time to live in seconds. Absent => the entry does not expire by time. */
   ttlSeconds?: number
 }
-/** Objeto devolvido por `cache.stats()`. Campos `i64` viram `number` no JS. */
+/** Object returned by `cache.stats()`. `i64` fields become `number` in JS. */
 export interface CacheStatsObject {
   hits: number
   misses: number
@@ -40,34 +40,34 @@ export interface CacheStatsObject {
   size: number
 }
 /**
- * Cache em memória exposto ao Node como a classe `Cache`.
+ * In-memory cache exposed to Node as the `Cache` class.
  *
- * Internamente delega tudo para o `RustCache` (que carrega o `DashMap` e os
- * contadores atômicos). Todos os métodos recebem `&self`: como o estado é
- * concorrente por dentro, várias chamadas podem rodar em paralelo.
+ * It delegates everything to `RustCache` (which holds the `DashMap` and the
+ * atomic counters). Every method takes `&self`: the state is concurrent
+ * inside, so it is safe to use from several threads (such as the sweeper).
  */
 export declare class Cache {
-  /** `new Cache()` ou `new Cache({ maxSize, evictionPolicy, cleanupIntervalSeconds })`. */
+  /** `new Cache()` or `new Cache({ maxSize, evictionPolicy, cleanupIntervalSeconds })`. */
   constructor(options?: CacheOptions | undefined | null)
-  /** A política de evicção ativa: `"reject"` ou `"lru"`. */
+  /** The active eviction policy: `"reject"` or `"lru"`. */
   get evictionPolicy(): string
   /**
-   * Insere/atualiza uma chave. Retorna `true` em sucesso, `false` se o cache
-   * estiver cheio (`maxSize`) e a chave for nova.
+   * Inserts or updates a key. Returns `true` on success, `false` if the cache
+   * is full (`maxSize`) and the key is new.
    */
   set(key: string, value: any, options?: SetOptions | undefined | null): boolean
-  /** Lê uma chave. Retorna o valor ou `null` se ausente/expirada. */
+  /** Reads a key. Returns the value, or `null` if missing or expired. */
   get(key: string): any | null
-  /** Remove uma chave. Retorna `true` se existia, `false` caso contrário. */
+  /** Removes a key. Returns `true` if it existed, `false` otherwise. */
   delete(key: string): boolean
-  /** Indica se a chave existe e está válida (não expirada). */
+  /** Whether the key exists and is still valid (not expired). */
   exists(key: string): boolean
-  /** Esvazia todas as entradas do cache. */
+  /** Removes every entry from the cache. */
   clear(): void
-  /** Quantidade de chaves armazenadas no momento. */
+  /** Number of keys currently stored. */
   size(): number
-  /** Varre e remove todas as entradas expiradas. Retorna quantas removeu. */
+  /** Sweeps and removes every expired entry. Returns how many it removed. */
   cleanupExpired(): number
-  /** Estatísticas acumuladas + tamanho atual. */
+  /** Accumulated statistics + the current size. */
   stats(): CacheStatsObject
 }

package/dist/express.d.mts

@@ -2,32 +2,32 @@ import { Request, Response, NextFunction } from 'express';
 import { Cache } from './index.mjs';
 
 /**
- * Integração com Express: cache de respostas JSON.
+ * Express integration: caching of JSON responses.
  *
- * Uso:
+ * Usage:
  *   import { Cache } from "rust-node-cache";
  *   import { cacheMiddleware } from "rust-node-cache/express";
  *
  *   const cache = new Cache();
  *   app.get("/users/:id", cacheMiddleware({ cache, ttlSeconds: 60 }), handler);
  *
- * O middleware intercepta `res.json`: num HIT responde direto do cache; num
- * MISS deixa o handler rodar e guarda o corpo da resposta (apenas em 2xx).
+ * The middleware intercepts `res.json`: on a HIT it responds straight from the
+ * cache; on a MISS it lets the handler run and stores the response body (2xx only).
  */
 
 interface CacheMiddlewareOptions {
-    /** Instância de cache a usar. */
+    /** Cache instance to use. */
     cache: Cache;
-    /** TTL aplicado às respostas guardadas (em segundos). */
+    /** TTL applied to stored responses (in seconds). */
     ttlSeconds?: number;
-    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    /** HTTP methods eligible for caching. Default: `["GET"]`. */
     methods?: string[];
-    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    /** Builds the cache key from the request. Default: `METHOD:url`. */
     keyGenerator?: (req: Request) => string;
 }
 /**
- * Cria um middleware Express que cacheia respostas JSON. Adiciona o cabeçalho
- * `X-Cache: HIT|MISS` para facilitar a observabilidade.
+ * Creates an Express middleware that caches JSON responses. Adds an
+ * `X-Cache: HIT|MISS` header for observability.
  */
 declare function cacheMiddleware(options: CacheMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => void;
 

package/dist/express.d.ts

@@ -2,32 +2,32 @@ import { Request, Response, NextFunction } from 'express';
 import { Cache } from './index.js';
 
 /**
- * Integração com Express: cache de respostas JSON.
+ * Express integration: caching of JSON responses.
  *
- * Uso:
+ * Usage:
  *   import { Cache } from "rust-node-cache";
  *   import { cacheMiddleware } from "rust-node-cache/express";
  *
  *   const cache = new Cache();
  *   app.get("/users/:id", cacheMiddleware({ cache, ttlSeconds: 60 }), handler);
  *
- * O middleware intercepta `res.json`: num HIT responde direto do cache; num
- * MISS deixa o handler rodar e guarda o corpo da resposta (apenas em 2xx).
+ * The middleware intercepts `res.json`: on a HIT it responds straight from the
+ * cache; on a MISS it lets the handler run and stores the response body (2xx only).
  */
 
 interface CacheMiddlewareOptions {
-    /** Instância de cache a usar. */
+    /** Cache instance to use. */
     cache: Cache;
-    /** TTL aplicado às respostas guardadas (em segundos). */
+    /** TTL applied to stored responses (in seconds). */
     ttlSeconds?: number;
-    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    /** HTTP methods eligible for caching. Default: `["GET"]`. */
     methods?: string[];
-    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    /** Builds the cache key from the request. Default: `METHOD:url`. */
     keyGenerator?: (req: Request) => string;
 }
 /**
- * Cria um middleware Express que cacheia respostas JSON. Adiciona o cabeçalho
- * `X-Cache: HIT|MISS` para facilitar a observabilidade.
+ * Creates an Express middleware that caches JSON responses. Adds an
+ * `X-Cache: HIT|MISS` header for observability.
  */
 declare function cacheMiddleware(options: CacheMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => void;
 

package/dist/express.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/express.ts"],"sourcesContent":["/**\n * Integração com Express: cache de respostas JSON.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cacheMiddleware } from \"rust-node-cache/express\";\n *\n *   const cache = new Cache();\n *   app.get(\"/users/:id\", cacheMiddleware({ cache, ttlSeconds: 60 }), handler);\n *\n * O middleware intercepta `res.json`: num HIT responde direto do cache; num\n * MISS deixa o handler rodar e guarda o corpo da resposta (apenas em 2xx).\n */\n\nimport type { Request, Response, NextFunction } from \"express\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheMiddlewareOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: Request) => string;\n}\n\n/**\n * Cria um middleware Express que cacheia respostas JSON. Adiciona o cabeçalho\n * `X-Cache: HIT|MISS` para facilitar a observabilidade.\n */\nexport function cacheMiddleware(options: CacheMiddlewareOptions) {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: Request) => `${req.method}:${req.originalUrl}`);\n\n  return function rustNodeCache(\n    req: Request,\n    res: Response,\n    next: NextFunction,\n  ): void {\n    if (!methods.includes(req.method)) {\n      next();\n      return;\n    }\n\n    const key = keyGenerator(req);\n    const cached = cache.get(key);\n    if (cached !== null) {\n      res.setHeader(\"X-Cache\", \"HIT\");\n      res.json(cached);\n      return;\n    }\n\n    res.setHeader(\"X-Cache\", \"MISS\");\n    const originalJson = res.json.bind(res);\n    res.json = (body: unknown): Response => {\n      // Só guardamos respostas bem-sucedidas (2xx).\n      if (res.statusCode >= 200 && res.statusCode < 300) {\n        cache.set(key, body, ttlSeconds ? { ttlSeconds } : undefined);\n      }\n      return originalJson(body);\n    };\n\n    next();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCO,SAAS,gBAAgB,SAAiC;AAC/D,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAiB,GAAG,IAAI,MAAM,IAAI,IAAI,WAAW;AAE7E,SAAO,SAAS,cACd,KACA,KACA,MACM;AACN,QAAI,CAAC,QAAQ,SAAS,IAAI,MAAM,GAAG;AACjC,WAAK;AACL;AAAA,IACF;AAEA,UAAM,MAAM,aAAa,GAAG;AAC5B,UAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,QAAI,WAAW,MAAM;AACnB,UAAI,UAAU,WAAW,KAAK;AAC9B,UAAI,KAAK,MAAM;AACf;AAAA,IACF;AAEA,QAAI,UAAU,WAAW,MAAM;AAC/B,UAAM,eAAe,IAAI,KAAK,KAAK,GAAG;AACtC,QAAI,OAAO,CAAC,SAA4B;AAEtC,UAAI,IAAI,cAAc,OAAO,IAAI,aAAa,KAAK;AACjD,cAAM,IAAI,KAAK,MAAM,aAAa,EAAE,WAAW,IAAI,MAAS;AAAA,MAC9D;AACA,aAAO,aAAa,IAAI;AAAA,IAC1B;AAEA,SAAK;AAAA,EACP;AACF;","names":[]}
+{"version":3,"sources":["../js/express.ts"],"sourcesContent":["/**\n * Express integration: caching of JSON responses.\n *\n * Usage:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cacheMiddleware } from \"rust-node-cache/express\";\n *\n *   const cache = new Cache();\n *   app.get(\"/users/:id\", cacheMiddleware({ cache, ttlSeconds: 60 }), handler);\n *\n * The middleware intercepts `res.json`: on a HIT it responds straight from the\n * cache; on a MISS it lets the handler run and stores the response body (2xx only).\n */\n\nimport type { Request, Response, NextFunction } from \"express\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheMiddlewareOptions {\n  /** Cache instance to use. */\n  cache: Cache;\n  /** TTL applied to stored responses (in seconds). */\n  ttlSeconds?: number;\n  /** HTTP methods eligible for caching. Default: `[\"GET\"]`. */\n  methods?: string[];\n  /** Builds the cache key from the request. Default: `METHOD:url`. */\n  keyGenerator?: (req: Request) => string;\n}\n\n/**\n * Creates an Express middleware that caches JSON responses. Adds an\n * `X-Cache: HIT|MISS` header for observability.\n */\nexport function cacheMiddleware(options: CacheMiddlewareOptions) {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: Request) => `${req.method}:${req.originalUrl}`);\n\n  return function rustNodeCache(\n    req: Request,\n    res: Response,\n    next: NextFunction,\n  ): void {\n    if (!methods.includes(req.method)) {\n      next();\n      return;\n    }\n\n    const key = keyGenerator(req);\n    const cached = cache.get(key);\n    if (cached !== null) {\n      res.setHeader(\"X-Cache\", \"HIT\");\n      res.json(cached);\n      return;\n    }\n\n    res.setHeader(\"X-Cache\", \"MISS\");\n    const originalJson = res.json.bind(res);\n    res.json = (body: unknown): Response => {\n      // Only successful responses (2xx) are stored.\n      if (res.statusCode >= 200 && res.statusCode < 300) {\n        cache.set(key, body, ttlSeconds ? { ttlSeconds } : undefined);\n      }\n      return originalJson(body);\n    };\n\n    next();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCO,SAAS,gBAAgB,SAAiC;AAC/D,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAiB,GAAG,IAAI,MAAM,IAAI,IAAI,WAAW;AAE7E,SAAO,SAAS,cACd,KACA,KACA,MACM;AACN,QAAI,CAAC,QAAQ,SAAS,IAAI,MAAM,GAAG;AACjC,WAAK;AACL;AAAA,IACF;AAEA,UAAM,MAAM,aAAa,GAAG;AAC5B,UAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,QAAI,WAAW,MAAM;AACnB,UAAI,UAAU,WAAW,KAAK;AAC9B,UAAI,KAAK,MAAM;AACf;AAAA,IACF;AAEA,QAAI,UAAU,WAAW,MAAM;AAC/B,UAAM,eAAe,IAAI,KAAK,KAAK,GAAG;AACtC,QAAI,OAAO,CAAC,SAA4B;AAEtC,UAAI,IAAI,cAAc,OAAO,IAAI,aAAa,KAAK;AACjD,cAAM,IAAI,KAAK,MAAM,aAAa,EAAE,WAAW,IAAI,MAAS;AAAA,MAC9D;AACA,aAAO,aAAa,IAAI;AAAA,IAC1B;AAEA,SAAK;AAAA,EACP;AACF;","names":[]}

package/dist/express.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/express.ts"],"sourcesContent":["/**\n * Integração com Express: cache de respostas JSON.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cacheMiddleware } from \"rust-node-cache/express\";\n *\n *   const cache = new Cache();\n *   app.get(\"/users/:id\", cacheMiddleware({ cache, ttlSeconds: 60 }), handler);\n *\n * O middleware intercepta `res.json`: num HIT responde direto do cache; num\n * MISS deixa o handler rodar e guarda o corpo da resposta (apenas em 2xx).\n */\n\nimport type { Request, Response, NextFunction } from \"express\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheMiddlewareOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: Request) => string;\n}\n\n/**\n * Cria um middleware Express que cacheia respostas JSON. Adiciona o cabeçalho\n * `X-Cache: HIT|MISS` para facilitar a observabilidade.\n */\nexport function cacheMiddleware(options: CacheMiddlewareOptions) {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: Request) => `${req.method}:${req.originalUrl}`);\n\n  return function rustNodeCache(\n    req: Request,\n    res: Response,\n    next: NextFunction,\n  ): void {\n    if (!methods.includes(req.method)) {\n      next();\n      return;\n    }\n\n    const key = keyGenerator(req);\n    const cached = cache.get(key);\n    if (cached !== null) {\n      res.setHeader(\"X-Cache\", \"HIT\");\n      res.json(cached);\n      return;\n    }\n\n    res.setHeader(\"X-Cache\", \"MISS\");\n    const originalJson = res.json.bind(res);\n    res.json = (body: unknown): Response => {\n      // Só guardamos respostas bem-sucedidas (2xx).\n      if (res.statusCode >= 200 && res.statusCode < 300) {\n        cache.set(key, body, ttlSeconds ? { ttlSeconds } : undefined);\n      }\n      return originalJson(body);\n    };\n\n    next();\n  };\n}\n"],"mappings":";AAgCO,SAAS,gBAAgB,SAAiC;AAC/D,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAiB,GAAG,IAAI,MAAM,IAAI,IAAI,WAAW;AAE7E,SAAO,SAAS,cACd,KACA,KACA,MACM;AACN,QAAI,CAAC,QAAQ,SAAS,IAAI,MAAM,GAAG;AACjC,WAAK;AACL;AAAA,IACF;AAEA,UAAM,MAAM,aAAa,GAAG;AAC5B,UAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,QAAI,WAAW,MAAM;AACnB,UAAI,UAAU,WAAW,KAAK;AAC9B,UAAI,KAAK,MAAM;AACf;AAAA,IACF;AAEA,QAAI,UAAU,WAAW,MAAM;AAC/B,UAAM,eAAe,IAAI,KAAK,KAAK,GAAG;AACtC,QAAI,OAAO,CAAC,SAA4B;AAEtC,UAAI,IAAI,cAAc,OAAO,IAAI,aAAa,KAAK;AACjD,cAAM,IAAI,KAAK,MAAM,aAAa,EAAE,WAAW,IAAI,MAAS;AAAA,MAC9D;AACA,aAAO,aAAa,IAAI;AAAA,IAC1B;AAEA,SAAK;AAAA,EACP;AACF;","names":[]}
+{"version":3,"sources":["../js/express.ts"],"sourcesContent":["/**\n * Express integration: caching of JSON responses.\n *\n * Usage:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cacheMiddleware } from \"rust-node-cache/express\";\n *\n *   const cache = new Cache();\n *   app.get(\"/users/:id\", cacheMiddleware({ cache, ttlSeconds: 60 }), handler);\n *\n * The middleware intercepts `res.json`: on a HIT it responds straight from the\n * cache; on a MISS it lets the handler run and stores the response body (2xx only).\n */\n\nimport type { Request, Response, NextFunction } from \"express\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheMiddlewareOptions {\n  /** Cache instance to use. */\n  cache: Cache;\n  /** TTL applied to stored responses (in seconds). */\n  ttlSeconds?: number;\n  /** HTTP methods eligible for caching. Default: `[\"GET\"]`. */\n  methods?: string[];\n  /** Builds the cache key from the request. Default: `METHOD:url`. */\n  keyGenerator?: (req: Request) => string;\n}\n\n/**\n * Creates an Express middleware that caches JSON responses. Adds an\n * `X-Cache: HIT|MISS` header for observability.\n */\nexport function cacheMiddleware(options: CacheMiddlewareOptions) {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: Request) => `${req.method}:${req.originalUrl}`);\n\n  return function rustNodeCache(\n    req: Request,\n    res: Response,\n    next: NextFunction,\n  ): void {\n    if (!methods.includes(req.method)) {\n      next();\n      return;\n    }\n\n    const key = keyGenerator(req);\n    const cached = cache.get(key);\n    if (cached !== null) {\n      res.setHeader(\"X-Cache\", \"HIT\");\n      res.json(cached);\n      return;\n    }\n\n    res.setHeader(\"X-Cache\", \"MISS\");\n    const originalJson = res.json.bind(res);\n    res.json = (body: unknown): Response => {\n      // Only successful responses (2xx) are stored.\n      if (res.statusCode >= 200 && res.statusCode < 300) {\n        cache.set(key, body, ttlSeconds ? { ttlSeconds } : undefined);\n      }\n      return originalJson(body);\n    };\n\n    next();\n  };\n}\n"],"mappings":";AAgCO,SAAS,gBAAgB,SAAiC;AAC/D,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAiB,GAAG,IAAI,MAAM,IAAI,IAAI,WAAW;AAE7E,SAAO,SAAS,cACd,KACA,KACA,MACM;AACN,QAAI,CAAC,QAAQ,SAAS,IAAI,MAAM,GAAG;AACjC,WAAK;AACL;AAAA,IACF;AAEA,UAAM,MAAM,aAAa,GAAG;AAC5B,UAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,QAAI,WAAW,MAAM;AACnB,UAAI,UAAU,WAAW,KAAK;AAC9B,UAAI,KAAK,MAAM;AACf;AAAA,IACF;AAEA,QAAI,UAAU,WAAW,MAAM;AAC/B,UAAM,eAAe,IAAI,KAAK,KAAK,GAAG;AACtC,QAAI,OAAO,CAAC,SAA4B;AAEtC,UAAI,IAAI,cAAc,OAAO,IAAI,aAAa,KAAK;AACjD,cAAM,IAAI,KAAK,MAAM,aAAa,EAAE,WAAW,IAAI,MAAS;AAAA,MAC9D;AACA,aAAO,aAAa,IAAI;AAAA,IAC1B;AAEA,SAAK;AAAA,EACP;AACF;","names":[]}

package/dist/fastify.d.mts

@@ -2,31 +2,31 @@ import { FastifyRequest, FastifyInstance } from 'fastify';
 import { Cache } from './index.mjs';
 
 /**
- * Integração com Fastify: cache de respostas JSON via plugin.
+ * Fastify integration: caching of JSON responses through a plugin.
  *
- * Uso:
+ * Usage:
  *   import { Cache } from "rust-node-cache";
  *   import { cachePlugin } from "rust-node-cache/fastify";
  *
  *   const cache = new Cache();
  *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });
  *
- * Fluxo: o hook `onRequest` checa o cache e, num HIT, responde imediatamente
- * (curto-circuito). Num MISS, o hook `onSend` guarda o payload serializado.
+ * Flow: the `onRequest` hook checks the cache and, on a HIT, responds right away
+ * (short-circuit). On a MISS, the `onSend` hook stores the serialized payload.
  */
 
 interface CachePluginOptions {
-    /** Instância de cache a usar. */
+    /** Cache instance to use. */
     cache: Cache;
-    /** TTL aplicado às respostas guardadas (em segundos). */
+    /** TTL applied to stored responses (in seconds). */
     ttlSeconds?: number;
-    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    /** HTTP methods eligible for caching. Default: `["GET"]`. */
     methods?: string[];
-    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    /** Builds the cache key from the request. Default: `METHOD:url`. */
     keyGenerator?: (req: FastifyRequest) => string;
 }
 /**
- * Plugin Fastify que cacheia respostas JSON. Use com `fastify.register`.
+ * Fastify plugin that caches JSON responses. Use it with `fastify.register`.
  */
 declare function cachePlugin(fastify: FastifyInstance, options: CachePluginOptions): Promise<void>;
 

package/dist/fastify.d.ts

@@ -2,31 +2,31 @@ import { FastifyRequest, FastifyInstance } from 'fastify';
 import { Cache } from './index.js';
 
 /**
- * Integração com Fastify: cache de respostas JSON via plugin.
+ * Fastify integration: caching of JSON responses through a plugin.
  *
- * Uso:
+ * Usage:
  *   import { Cache } from "rust-node-cache";
  *   import { cachePlugin } from "rust-node-cache/fastify";
  *
  *   const cache = new Cache();
  *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });
  *
- * Fluxo: o hook `onRequest` checa o cache e, num HIT, responde imediatamente
- * (curto-circuito). Num MISS, o hook `onSend` guarda o payload serializado.
+ * Flow: the `onRequest` hook checks the cache and, on a HIT, responds right away
+ * (short-circuit). On a MISS, the `onSend` hook stores the serialized payload.
  */
 
 interface CachePluginOptions {
-    /** Instância de cache a usar. */
+    /** Cache instance to use. */
     cache: Cache;
-    /** TTL aplicado às respostas guardadas (em segundos). */
+    /** TTL applied to stored responses (in seconds). */
     ttlSeconds?: number;
-    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    /** HTTP methods eligible for caching. Default: `["GET"]`. */
     methods?: string[];
-    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    /** Builds the cache key from the request. Default: `METHOD:url`. */
     keyGenerator?: (req: FastifyRequest) => string;
 }
 /**
- * Plugin Fastify que cacheia respostas JSON. Use com `fastify.register`.
+ * Fastify plugin that caches JSON responses. Use it with `fastify.register`.
  */
 declare function cachePlugin(fastify: FastifyInstance, options: CachePluginOptions): Promise<void>;
 

package/dist/fastify.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/fastify.ts"],"sourcesContent":["/**\n * Integração com Fastify: cache de respostas JSON via plugin.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cachePlugin } from \"rust-node-cache/fastify\";\n *\n *   const cache = new Cache();\n *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });\n *\n * Fluxo: o hook `onRequest` checa o cache e, num HIT, responde imediatamente\n * (curto-circuito). Num MISS, o hook `onSend` guarda o payload serializado.\n */\n\nimport type {\n  FastifyInstance,\n  FastifyReply,\n  FastifyRequest,\n} from \"fastify\";\nimport type { Cache } from \"./index\";\n\nexport interface CachePluginOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: FastifyRequest) => string;\n}\n\n// Guardamos a chave calculada na própria request entre os hooks.\nconst CACHE_KEY = Symbol(\"rustNodeCacheKey\");\n\n/**\n * Plugin Fastify que cacheia respostas JSON. Use com `fastify.register`.\n */\nexport async function cachePlugin(\n  fastify: FastifyInstance,\n  options: CachePluginOptions,\n): Promise<void> {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: FastifyRequest) => `${req.method}:${req.url}`);\n\n  fastify.addHook(\n    \"onRequest\",\n    (request: FastifyRequest, reply: FastifyReply, done: () => void) => {\n      if (!methods.includes(request.method)) {\n        done();\n        return;\n      }\n\n      const key = keyGenerator(request);\n      const cached = cache.get(key);\n      if (cached !== null) {\n        reply.header(\"X-Cache\", \"HIT\");\n        reply.send(cached);\n        return; // não chama done(): a resposta já foi enviada.\n      }\n\n      reply.header(\"X-Cache\", \"MISS\");\n      (request as unknown as Record<symbol, string>)[CACHE_KEY] = key;\n      done();\n    },\n  );\n\n  fastify.addHook(\n    \"onSend\",\n    (\n      request: FastifyRequest,\n      reply: FastifyReply,\n      payload: unknown,\n      done: (err: Error | null, value?: unknown) => void,\n    ) => {\n      const key = (request as unknown as Record<symbol, string | undefined>)[\n        CACHE_KEY\n      ];\n      if (\n        key &&\n        typeof payload === \"string\" &&\n        reply.statusCode >= 200 &&\n        reply.statusCode < 300\n      ) {\n        try {\n          cache.set(\n            key,\n            JSON.parse(payload),\n            ttlSeconds ? { ttlSeconds } : undefined,\n          );\n        } catch {\n          // payload não-JSON: simplesmente não cacheia.\n        }\n      }\n      done(null, payload);\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,IAAM,YAAY,uBAAO,kBAAkB;AAK3C,eAAsB,YACpB,SACA,SACe;AACf,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAwB,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAE5E,UAAQ;AAAA,IACN;AAAA,IACA,CAAC,SAAyB,OAAqB,SAAqB;AAClE,UAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,GAAG;AACrC,aAAK;AACL;AAAA,MACF;AAEA,YAAM,MAAM,aAAa,OAAO;AAChC,YAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,UAAI,WAAW,MAAM;AACnB,cAAM,OAAO,WAAW,KAAK;AAC7B,cAAM,KAAK,MAAM;AACjB;AAAA,MACF;AAEA,YAAM,OAAO,WAAW,MAAM;AAC9B,MAAC,QAA8C,SAAS,IAAI;AAC5D,WAAK;AAAA,IACP;AAAA,EACF;AAEA,UAAQ;AAAA,IACN;AAAA,IACA,CACE,SACA,OACA,SACA,SACG;AACH,YAAM,MAAO,QACX,SACF;AACA,UACE,OACA,OAAO,YAAY,YACnB,MAAM,cAAc,OACpB,MAAM,aAAa,KACnB;AACA,YAAI;AACF,gBAAM;AAAA,YACJ;AAAA,YACA,KAAK,MAAM,OAAO;AAAA,YAClB,aAAa,EAAE,WAAW,IAAI;AAAA,UAChC;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AACA,WAAK,MAAM,OAAO;AAAA,IACpB;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../js/fastify.ts"],"sourcesContent":["/**\n * Fastify integration: caching of JSON responses through a plugin.\n *\n * Usage:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cachePlugin } from \"rust-node-cache/fastify\";\n *\n *   const cache = new Cache();\n *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });\n *\n * Flow: the `onRequest` hook checks the cache and, on a HIT, responds right away\n * (short-circuit). On a MISS, the `onSend` hook stores the serialized payload.\n */\n\nimport type {\n  FastifyInstance,\n  FastifyReply,\n  FastifyRequest,\n} from \"fastify\";\nimport type { Cache } from \"./index\";\n\nexport interface CachePluginOptions {\n  /** Cache instance to use. */\n  cache: Cache;\n  /** TTL applied to stored responses (in seconds). */\n  ttlSeconds?: number;\n  /** HTTP methods eligible for caching. Default: `[\"GET\"]`. */\n  methods?: string[];\n  /** Builds the cache key from the request. Default: `METHOD:url`. */\n  keyGenerator?: (req: FastifyRequest) => string;\n}\n\n// The computed key is kept on the request itself between hooks.\nconst CACHE_KEY = Symbol(\"rustNodeCacheKey\");\n\n/**\n * Fastify plugin that caches JSON responses. Use it with `fastify.register`.\n */\nexport async function cachePlugin(\n  fastify: FastifyInstance,\n  options: CachePluginOptions,\n): Promise<void> {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: FastifyRequest) => `${req.method}:${req.url}`);\n\n  fastify.addHook(\n    \"onRequest\",\n    (request: FastifyRequest, reply: FastifyReply, done: () => void) => {\n      if (!methods.includes(request.method)) {\n        done();\n        return;\n      }\n\n      const key = keyGenerator(request);\n      const cached = cache.get(key);\n      if (cached !== null) {\n        reply.header(\"X-Cache\", \"HIT\");\n        reply.send(cached);\n        return; // done() is not called: the response was already sent.\n      }\n\n      reply.header(\"X-Cache\", \"MISS\");\n      (request as unknown as Record<symbol, string>)[CACHE_KEY] = key;\n      done();\n    },\n  );\n\n  fastify.addHook(\n    \"onSend\",\n    (\n      request: FastifyRequest,\n      reply: FastifyReply,\n      payload: unknown,\n      done: (err: Error | null, value?: unknown) => void,\n    ) => {\n      const key = (request as unknown as Record<symbol, string | undefined>)[\n        CACHE_KEY\n      ];\n      if (\n        key &&\n        typeof payload === \"string\" &&\n        reply.statusCode >= 200 &&\n        reply.statusCode < 300\n      ) {\n        try {\n          cache.set(\n            key,\n            JSON.parse(payload),\n            ttlSeconds ? { ttlSeconds } : undefined,\n          );\n        } catch {\n          // non-JSON payload: simply not cached.\n        }\n      }\n      done(null, payload);\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,IAAM,YAAY,uBAAO,kBAAkB;AAK3C,eAAsB,YACpB,SACA,SACe;AACf,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAwB,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAE5E,UAAQ;AAAA,IACN;AAAA,IACA,CAAC,SAAyB,OAAqB,SAAqB;AAClE,UAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,GAAG;AACrC,aAAK;AACL;AAAA,MACF;AAEA,YAAM,MAAM,aAAa,OAAO;AAChC,YAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,UAAI,WAAW,MAAM;AACnB,cAAM,OAAO,WAAW,KAAK;AAC7B,cAAM,KAAK,MAAM;AACjB;AAAA,MACF;AAEA,YAAM,OAAO,WAAW,MAAM;AAC9B,MAAC,QAA8C,SAAS,IAAI;AAC5D,WAAK;AAAA,IACP;AAAA,EACF;AAEA,UAAQ;AAAA,IACN;AAAA,IACA,CACE,SACA,OACA,SACA,SACG;AACH,YAAM,MAAO,QACX,SACF;AACA,UACE,OACA,OAAO,YAAY,YACnB,MAAM,cAAc,OACpB,MAAM,aAAa,KACnB;AACA,YAAI;AACF,gBAAM;AAAA,YACJ;AAAA,YACA,KAAK,MAAM,OAAO;AAAA,YAClB,aAAa,EAAE,WAAW,IAAI;AAAA,UAChC;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AACA,WAAK,MAAM,OAAO;AAAA,IACpB;AAAA,EACF;AACF;","names":[]}

package/dist/fastify.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/fastify.ts"],"sourcesContent":["/**\n * Integração com Fastify: cache de respostas JSON via plugin.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cachePlugin } from \"rust-node-cache/fastify\";\n *\n *   const cache = new Cache();\n *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });\n *\n * Fluxo: o hook `onRequest` checa o cache e, num HIT, responde imediatamente\n * (curto-circuito). Num MISS, o hook `onSend` guarda o payload serializado.\n */\n\nimport type {\n  FastifyInstance,\n  FastifyReply,\n  FastifyRequest,\n} from \"fastify\";\nimport type { Cache } from \"./index\";\n\nexport interface CachePluginOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: FastifyRequest) => string;\n}\n\n// Guardamos a chave calculada na própria request entre os hooks.\nconst CACHE_KEY = Symbol(\"rustNodeCacheKey\");\n\n/**\n * Plugin Fastify que cacheia respostas JSON. Use com `fastify.register`.\n */\nexport async function cachePlugin(\n  fastify: FastifyInstance,\n  options: CachePluginOptions,\n): Promise<void> {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: FastifyRequest) => `${req.method}:${req.url}`);\n\n  fastify.addHook(\n    \"onRequest\",\n    (request: FastifyRequest, reply: FastifyReply, done: () => void) => {\n      if (!methods.includes(request.method)) {\n        done();\n        return;\n      }\n\n      const key = keyGenerator(request);\n      const cached = cache.get(key);\n      if (cached !== null) {\n        reply.header(\"X-Cache\", \"HIT\");\n        reply.send(cached);\n        return; // não chama done(): a resposta já foi enviada.\n      }\n\n      reply.header(\"X-Cache\", \"MISS\");\n      (request as unknown as Record<symbol, string>)[CACHE_KEY] = key;\n      done();\n    },\n  );\n\n  fastify.addHook(\n    \"onSend\",\n    (\n      request: FastifyRequest,\n      reply: FastifyReply,\n      payload: unknown,\n      done: (err: Error | null, value?: unknown) => void,\n    ) => {\n      const key = (request as unknown as Record<symbol, string | undefined>)[\n        CACHE_KEY\n      ];\n      if (\n        key &&\n        typeof payload === \"string\" &&\n        reply.statusCode >= 200 &&\n        reply.statusCode < 300\n      ) {\n        try {\n          cache.set(\n            key,\n            JSON.parse(payload),\n            ttlSeconds ? { ttlSeconds } : undefined,\n          );\n        } catch {\n          // payload não-JSON: simplesmente não cacheia.\n        }\n      }\n      done(null, payload);\n    },\n  );\n}\n"],"mappings":";AAiCA,IAAM,YAAY,uBAAO,kBAAkB;AAK3C,eAAsB,YACpB,SACA,SACe;AACf,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAwB,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAE5E,UAAQ;AAAA,IACN;AAAA,IACA,CAAC,SAAyB,OAAqB,SAAqB;AAClE,UAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,GAAG;AACrC,aAAK;AACL;AAAA,MACF;AAEA,YAAM,MAAM,aAAa,OAAO;AAChC,YAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,UAAI,WAAW,MAAM;AACnB,cAAM,OAAO,WAAW,KAAK;AAC7B,cAAM,KAAK,MAAM;AACjB;AAAA,MACF;AAEA,YAAM,OAAO,WAAW,MAAM;AAC9B,MAAC,QAA8C,SAAS,IAAI;AAC5D,WAAK;AAAA,IACP;AAAA,EACF;AAEA,UAAQ;AAAA,IACN;AAAA,IACA,CACE,SACA,OACA,SACA,SACG;AACH,YAAM,MAAO,QACX,SACF;AACA,UACE,OACA,OAAO,YAAY,YACnB,MAAM,cAAc,OACpB,MAAM,aAAa,KACnB;AACA,YAAI;AACF,gBAAM;AAAA,YACJ;AAAA,YACA,KAAK,MAAM,OAAO;AAAA,YAClB,aAAa,EAAE,WAAW,IAAI;AAAA,UAChC;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AACA,WAAK,MAAM,OAAO;AAAA,IACpB;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../js/fastify.ts"],"sourcesContent":["/**\n * Fastify integration: caching of JSON responses through a plugin.\n *\n * Usage:\n *   import { Cache } from \"rust-node-cache\";\n *   import { cachePlugin } from \"rust-node-cache/fastify\";\n *\n *   const cache = new Cache();\n *   fastify.register(cachePlugin, { cache, ttlSeconds: 60 });\n *\n * Flow: the `onRequest` hook checks the cache and, on a HIT, responds right away\n * (short-circuit). On a MISS, the `onSend` hook stores the serialized payload.\n */\n\nimport type {\n  FastifyInstance,\n  FastifyReply,\n  FastifyRequest,\n} from \"fastify\";\nimport type { Cache } from \"./index\";\n\nexport interface CachePluginOptions {\n  /** Cache instance to use. */\n  cache: Cache;\n  /** TTL applied to stored responses (in seconds). */\n  ttlSeconds?: number;\n  /** HTTP methods eligible for caching. Default: `[\"GET\"]`. */\n  methods?: string[];\n  /** Builds the cache key from the request. Default: `METHOD:url`. */\n  keyGenerator?: (req: FastifyRequest) => string;\n}\n\n// The computed key is kept on the request itself between hooks.\nconst CACHE_KEY = Symbol(\"rustNodeCacheKey\");\n\n/**\n * Fastify plugin that caches JSON responses. Use it with `fastify.register`.\n */\nexport async function cachePlugin(\n  fastify: FastifyInstance,\n  options: CachePluginOptions,\n): Promise<void> {\n  const { cache } = options;\n  const ttlSeconds = options.ttlSeconds;\n  const methods = options.methods ?? [\"GET\"];\n  const keyGenerator =\n    options.keyGenerator ?? ((req: FastifyRequest) => `${req.method}:${req.url}`);\n\n  fastify.addHook(\n    \"onRequest\",\n    (request: FastifyRequest, reply: FastifyReply, done: () => void) => {\n      if (!methods.includes(request.method)) {\n        done();\n        return;\n      }\n\n      const key = keyGenerator(request);\n      const cached = cache.get(key);\n      if (cached !== null) {\n        reply.header(\"X-Cache\", \"HIT\");\n        reply.send(cached);\n        return; // done() is not called: the response was already sent.\n      }\n\n      reply.header(\"X-Cache\", \"MISS\");\n      (request as unknown as Record<symbol, string>)[CACHE_KEY] = key;\n      done();\n    },\n  );\n\n  fastify.addHook(\n    \"onSend\",\n    (\n      request: FastifyRequest,\n      reply: FastifyReply,\n      payload: unknown,\n      done: (err: Error | null, value?: unknown) => void,\n    ) => {\n      const key = (request as unknown as Record<symbol, string | undefined>)[\n        CACHE_KEY\n      ];\n      if (\n        key &&\n        typeof payload === \"string\" &&\n        reply.statusCode >= 200 &&\n        reply.statusCode < 300\n      ) {\n        try {\n          cache.set(\n            key,\n            JSON.parse(payload),\n            ttlSeconds ? { ttlSeconds } : undefined,\n          );\n        } catch {\n          // non-JSON payload: simply not cached.\n        }\n      }\n      done(null, payload);\n    },\n  );\n}\n"],"mappings":";AAiCA,IAAM,YAAY,uBAAO,kBAAkB;AAK3C,eAAsB,YACpB,SACA,SACe;AACf,QAAM,EAAE,MAAM,IAAI;AAClB,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,QAAQ,WAAW,CAAC,KAAK;AACzC,QAAM,eACJ,QAAQ,iBAAiB,CAAC,QAAwB,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAE5E,UAAQ;AAAA,IACN;AAAA,IACA,CAAC,SAAyB,OAAqB,SAAqB;AAClE,UAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,GAAG;AACrC,aAAK;AACL;AAAA,MACF;AAEA,YAAM,MAAM,aAAa,OAAO;AAChC,YAAM,SAAS,MAAM,IAAI,GAAG;AAC5B,UAAI,WAAW,MAAM;AACnB,cAAM,OAAO,WAAW,KAAK;AAC7B,cAAM,KAAK,MAAM;AACjB;AAAA,MACF;AAEA,YAAM,OAAO,WAAW,MAAM;AAC9B,MAAC,QAA8C,SAAS,IAAI;AAC5D,WAAK;AAAA,IACP;AAAA,EACF;AAEA,UAAQ;AAAA,IACN;AAAA,IACA,CACE,SACA,OACA,SACA,SACG;AACH,YAAM,MAAO,QACX,SACF;AACA,UACE,OACA,OAAO,YAAY,YACnB,MAAM,cAAc,OACpB,MAAM,aAAa,KACnB;AACA,YAAI;AACF,gBAAM;AAAA,YACJ;AAAA,YACA,KAAK,MAAM,OAAO;AAAA,YAClB,aAAa,EAAE,WAAW,IAAI;AAAA,UAChC;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AACA,WAAK,MAAM,OAAO;AAAA,IACpB;AAAA,EACF;AACF;","names":[]}

package/dist/index.d.mts

@@ -1,63 +1,63 @@
 /**
- * rust-node-cache — API pública (TypeScript).
+ * rust-node-cache — public API (TypeScript).
  *
  * "Ultra-fast in-memory cache powered by Rust."
  *
- * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada
- * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?
- *  - permite **genéricos** ergonômicos: `cache.get<User>("user:1")`;
- *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;
- *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.
+ * This layer is a thin, typed wrapper over the native `Cache` class generated
+ * by Rust/napi-rs. Why wrap it instead of re-exporting it directly?
+ *  - it allows ergonomic **generics**: `cache.get<User>("user:1")`;
+ *  - it normalizes `undefined`/`null` so a miss always returns `null`;
+ *  - it gives one place for the JSDoc and for evolving the API without breaking the Rust core.
  *
- * O custo é uma chamada de função extra por operação — desprezível frente ao
- * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.
+ * The cost is one extra function call per operation — negligible next to the
+ * real work (serialization + DashMap access) done in Rust.
  */
-/** Estratégia de evicção quando `maxSize` é atingido. */
+/** Eviction strategy when `maxSize` is reached. */
 type EvictionPolicy = "reject" | "lru";
-/** Opções do construtor do cache. */
+/** Cache constructor options. */
 interface CacheOptions {
     /**
-     * Limite máximo de chaves. O que acontece ao atingir depende de
-     * `evictionPolicy`. Sem valor => cache ilimitado.
+     * Maximum number of keys. What happens when it is reached depends on
+     * `evictionPolicy`. No value => unlimited cache.
      */
     maxSize?: number;
     /**
-     * Política ao atingir `maxSize` numa chave **nova**:
-     * - `"reject"` (padrão): `set` retorna `false` (sobrescrever continua ok);
-     * - `"lru"`: remove a entrada menos recentemente usada e prossegue.
+     * Policy when `maxSize` is reached on a **new** key:
+     * - `"reject"` (default): `set` returns `false` (overwriting still works);
+     * - `"lru"`: removes the least recently used entry and goes on.
      */
     evictionPolicy?: EvictionPolicy;
     /**
-     * Se definido (> 0), liga uma thread que varre entradas expiradas a cada
-     * N segundos (expiração em background, além da preguiçosa por acesso).
+     * When set (> 0), starts a thread that sweeps expired entries every N
+     * seconds (background expiration, on top of the lazy one on access).
      */
     cleanupIntervalSeconds?: number;
 }
-/** Opções por operação de escrita. */
+/** Per-write options. */
 interface SetOptions {
-    /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */
+    /** Time to live in seconds. Absent => the entry does not expire by time. */
     ttlSeconds?: number;
 }
-/** Estatísticas acumuladas do cache (mais o tamanho atual). */
+/** Accumulated cache statistics (plus the current size). */
 interface CacheStats {
-    /** Leituras que encontraram uma entrada válida. */
+    /** Reads that found a valid entry. */
     hits: number;
-    /** Leituras sem chave válida (ausente ou expirada). */
+    /** Reads without a valid key (missing or expired). */
     misses: number;
-    /** Total de escritas (`set`). */
+    /** Total writes (`set`). */
     sets: number;
-    /** Total de remoções explícitas (`delete`). */
+    /** Total explicit removals (`delete`). */
     deletes: number;
-    /** Total de entradas removidas por expiração. */
+    /** Total entries removed by expiration. */
     expired: number;
-    /** Total de entradas removidas por evicção (política LRU ao atingir `maxSize`). */
+    /** Total entries removed by eviction (LRU policy when `maxSize` is reached). */
     evicted: number;
-    /** Número de chaves armazenadas agora. */
+    /** Number of keys stored right now. */
     size: number;
 }
 /**
- * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores
- * atômicos). Thread-safe e com suporte a TTL por entrada.
+ * In-memory cache with a Rust core (DashMap + atomic counters). Thread-safe,
+ * with an optional TTL per entry.
  *
  * @example
  * ```ts
@@ -69,38 +69,38 @@ interface CacheStats {
  * ```
  */
 declare class Cache {
-    /** Instância da classe nativa (Rust). */
+    /** Instance of the native (Rust) class. */
     private readonly native;
     constructor(options?: CacheOptions);
-    /** A política de evicção ativa: `"reject"` ou `"lru"`. */
+    /** The active eviction policy: `"reject"` or `"lru"`. */
     get evictionPolicy(): EvictionPolicy;
     /**
-     * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+     * Stores (or overwrites) a value. The value is serialized as JSON in the core.
      *
-     * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+     * @returns `true` on success; `false` if `maxSize` was reached and the key is new.
      */
     set<T>(key: string, value: T, options?: SetOptions): boolean;
     /**
-     * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+     * Reads a value. Applies lazy expiration: expired keys count as a miss.
      *
-     * @returns o valor desserializado, ou `null` se ausente/expirado.
+     * @returns the deserialized value, or `null` if missing or expired.
      */
     get<T = unknown>(key: string): T | null;
-    /** Remove uma chave. Retorna `true` se ela existia. */
+    /** Removes a key. Returns `true` if it existed. */
     delete(key: string): boolean;
-    /** Indica se a chave existe e está válida (não expirada). */
+    /** Whether the key exists and is still valid (not expired). */
     exists(key: string): boolean;
-    /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+    /** Empties the cache (does not reset the historical `stats` counters). */
     clear(): void;
-    /** Número de chaves armazenadas no momento. */
+    /** Number of keys currently stored. */
     size(): number;
     /**
-     * Varre e remove todas as entradas expiradas de uma só vez.
+     * Sweeps and removes every expired entry at once.
      *
-     * @returns quantas entradas foram removidas.
+     * @returns how many entries were removed.
      */
     cleanupExpired(): number;
-    /** Retorna as estatísticas acumuladas + o tamanho atual. */
+    /** Returns the accumulated statistics + the current size. */
     stats(): CacheStats;
 }
 

package/dist/index.d.ts

@@ -1,63 +1,63 @@
 /**
- * rust-node-cache — API pública (TypeScript).
+ * rust-node-cache — public API (TypeScript).
  *
  * "Ultra-fast in-memory cache powered by Rust."
  *
- * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada
- * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?
- *  - permite **genéricos** ergonômicos: `cache.get<User>("user:1")`;
- *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;
- *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.
+ * This layer is a thin, typed wrapper over the native `Cache` class generated
+ * by Rust/napi-rs. Why wrap it instead of re-exporting it directly?
+ *  - it allows ergonomic **generics**: `cache.get<User>("user:1")`;
+ *  - it normalizes `undefined`/`null` so a miss always returns `null`;
+ *  - it gives one place for the JSDoc and for evolving the API without breaking the Rust core.
  *
- * O custo é uma chamada de função extra por operação — desprezível frente ao
- * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.
+ * The cost is one extra function call per operation — negligible next to the
+ * real work (serialization + DashMap access) done in Rust.
  */
-/** Estratégia de evicção quando `maxSize` é atingido. */
+/** Eviction strategy when `maxSize` is reached. */
 type EvictionPolicy = "reject" | "lru";
-/** Opções do construtor do cache. */
+/** Cache constructor options. */
 interface CacheOptions {
     /**
-     * Limite máximo de chaves. O que acontece ao atingir depende de
-     * `evictionPolicy`. Sem valor => cache ilimitado.
+     * Maximum number of keys. What happens when it is reached depends on
+     * `evictionPolicy`. No value => unlimited cache.
      */
     maxSize?: number;
     /**
-     * Política ao atingir `maxSize` numa chave **nova**:
-     * - `"reject"` (padrão): `set` retorna `false` (sobrescrever continua ok);
-     * - `"lru"`: remove a entrada menos recentemente usada e prossegue.
+     * Policy when `maxSize` is reached on a **new** key:
+     * - `"reject"` (default): `set` returns `false` (overwriting still works);
+     * - `"lru"`: removes the least recently used entry and goes on.
      */
     evictionPolicy?: EvictionPolicy;
     /**
-     * Se definido (> 0), liga uma thread que varre entradas expiradas a cada
-     * N segundos (expiração em background, além da preguiçosa por acesso).
+     * When set (> 0), starts a thread that sweeps expired entries every N
+     * seconds (background expiration, on top of the lazy one on access).
      */
     cleanupIntervalSeconds?: number;
 }
-/** Opções por operação de escrita. */
+/** Per-write options. */
 interface SetOptions {
-    /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */
+    /** Time to live in seconds. Absent => the entry does not expire by time. */
     ttlSeconds?: number;
 }
-/** Estatísticas acumuladas do cache (mais o tamanho atual). */
+/** Accumulated cache statistics (plus the current size). */
 interface CacheStats {
-    /** Leituras que encontraram uma entrada válida. */
+    /** Reads that found a valid entry. */
     hits: number;
-    /** Leituras sem chave válida (ausente ou expirada). */
+    /** Reads without a valid key (missing or expired). */
     misses: number;
-    /** Total de escritas (`set`). */
+    /** Total writes (`set`). */
     sets: number;
-    /** Total de remoções explícitas (`delete`). */
+    /** Total explicit removals (`delete`). */
     deletes: number;
-    /** Total de entradas removidas por expiração. */
+    /** Total entries removed by expiration. */
     expired: number;
-    /** Total de entradas removidas por evicção (política LRU ao atingir `maxSize`). */
+    /** Total entries removed by eviction (LRU policy when `maxSize` is reached). */
     evicted: number;
-    /** Número de chaves armazenadas agora. */
+    /** Number of keys stored right now. */
     size: number;
 }
 /**
- * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores
- * atômicos). Thread-safe e com suporte a TTL por entrada.
+ * In-memory cache with a Rust core (DashMap + atomic counters). Thread-safe,
+ * with an optional TTL per entry.
  *
  * @example
  * ```ts
@@ -69,38 +69,38 @@ interface CacheStats {
  * ```
  */
 declare class Cache {
-    /** Instância da classe nativa (Rust). */
+    /** Instance of the native (Rust) class. */
     private readonly native;
     constructor(options?: CacheOptions);
-    /** A política de evicção ativa: `"reject"` ou `"lru"`. */
+    /** The active eviction policy: `"reject"` or `"lru"`. */
     get evictionPolicy(): EvictionPolicy;
     /**
-     * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+     * Stores (or overwrites) a value. The value is serialized as JSON in the core.
      *
-     * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+     * @returns `true` on success; `false` if `maxSize` was reached and the key is new.
      */
     set<T>(key: string, value: T, options?: SetOptions): boolean;
     /**
-     * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+     * Reads a value. Applies lazy expiration: expired keys count as a miss.
      *
-     * @returns o valor desserializado, ou `null` se ausente/expirado.
+     * @returns the deserialized value, or `null` if missing or expired.
      */
     get<T = unknown>(key: string): T | null;
-    /** Remove uma chave. Retorna `true` se ela existia. */
+    /** Removes a key. Returns `true` if it existed. */
     delete(key: string): boolean;
-    /** Indica se a chave existe e está válida (não expirada). */
+    /** Whether the key exists and is still valid (not expired). */
     exists(key: string): boolean;
-    /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+    /** Empties the cache (does not reset the historical `stats` counters). */
     clear(): void;
-    /** Número de chaves armazenadas no momento. */
+    /** Number of keys currently stored. */
     size(): number;
     /**
-     * Varre e remove todas as entradas expiradas de uma só vez.
+     * Sweeps and removes every expired entry at once.
      *
-     * @returns quantas entradas foram removidas.
+     * @returns how many entries were removed.
      */
     cleanupExpired(): number;
-    /** Retorna as estatísticas acumuladas + o tamanho atual. */
+    /** Returns the accumulated statistics + the current size. */
     stats(): CacheStats;
 }
 

package/dist/index.js

@@ -43,52 +43,52 @@ var Cache2 = class {
       cleanupIntervalSeconds: options.cleanupIntervalSeconds
     }) : new native.Cache();
   }
-  /** A política de evicção ativa: `"reject"` ou `"lru"`. */
+  /** The active eviction policy: `"reject"` or `"lru"`. */
   get evictionPolicy() {
     return this.native.evictionPolicy;
   }
   /**
-   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+   * Stores (or overwrites) a value. The value is serialized as JSON in the core.
    *
-   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+   * @returns `true` on success; `false` if `maxSize` was reached and the key is new.
    */
   set(key, value, options) {
     return this.native.set(key, value, options);
   }
   /**
-   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+   * Reads a value. Applies lazy expiration: expired keys count as a miss.
    *
-   * @returns o valor desserializado, ou `null` se ausente/expirado.
+   * @returns the deserialized value, or `null` if missing or expired.
    */
   get(key) {
     const value = this.native.get(key);
     return value === null || value === void 0 ? null : value;
   }
-  /** Remove uma chave. Retorna `true` se ela existia. */
+  /** Removes a key. Returns `true` if it existed. */
   delete(key) {
     return this.native.delete(key);
   }
-  /** Indica se a chave existe e está válida (não expirada). */
+  /** Whether the key exists and is still valid (not expired). */
   exists(key) {
     return this.native.exists(key);
   }
-  /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+  /** Empties the cache (does not reset the historical `stats` counters). */
   clear() {
     this.native.clear();
   }
-  /** Número de chaves armazenadas no momento. */
+  /** Number of keys currently stored. */
   size() {
     return this.native.size();
   }
   /**
-   * Varre e remove todas as entradas expiradas de uma só vez.
+   * Sweeps and removes every expired entry at once.
    *
-   * @returns quantas entradas foram removidas.
+   * @returns how many entries were removed.
    */
   cleanupExpired() {
     return this.native.cleanupExpired();
   }
-  /** Retorna as estatísticas acumuladas + o tamanho atual. */
+  /** Returns the accumulated statistics + the current size. */
   stats() {
     return this.native.stats();
   }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/index.ts"],"sourcesContent":["/**\n * rust-node-cache — API pública (TypeScript).\n *\n * \"Ultra-fast in-memory cache powered by Rust.\"\n *\n * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada\n * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?\n *  - permite **genéricos** ergonômicos: `cache.get<User>(\"user:1\")`;\n *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;\n *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.\n *\n * O custo é uma chamada de função extra por operação — desprezível frente ao\n * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.\n */\n\n// Namespace import: funciona igual em CommonJS e ESM ao consumir o addon nativo\n// (que é um módulo CJS gerado pelo napi-rs).\nimport * as native from \"../binding.js\";\n\n/** Estratégia de evicção quando `maxSize` é atingido. */\nexport type EvictionPolicy = \"reject\" | \"lru\";\n\n/** Opções do construtor do cache. */\nexport interface CacheOptions {\n  /**\n   * Limite máximo de chaves. O que acontece ao atingir depende de\n   * `evictionPolicy`. Sem valor => cache ilimitado.\n   */\n  maxSize?: number;\n  /**\n   * Política ao atingir `maxSize` numa chave **nova**:\n   * - `\"reject\"` (padrão): `set` retorna `false` (sobrescrever continua ok);\n   * - `\"lru\"`: remove a entrada menos recentemente usada e prossegue.\n   */\n  evictionPolicy?: EvictionPolicy;\n  /**\n   * Se definido (> 0), liga uma thread que varre entradas expiradas a cada\n   * N segundos (expiração em background, além da preguiçosa por acesso).\n   */\n  cleanupIntervalSeconds?: number;\n}\n\n/** Opções por operação de escrita. */\nexport interface SetOptions {\n  /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */\n  ttlSeconds?: number;\n}\n\n/** Estatísticas acumuladas do cache (mais o tamanho atual). */\nexport interface CacheStats {\n  /** Leituras que encontraram uma entrada válida. */\n  hits: number;\n  /** Leituras sem chave válida (ausente ou expirada). */\n  misses: number;\n  /** Total de escritas (`set`). */\n  sets: number;\n  /** Total de remoções explícitas (`delete`). */\n  deletes: number;\n  /** Total de entradas removidas por expiração. */\n  expired: number;\n  /** Total de entradas removidas por evicção (política LRU ao atingir `maxSize`). */\n  evicted: number;\n  /** Número de chaves armazenadas agora. */\n  size: number;\n}\n\n/**\n * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores\n * atômicos). Thread-safe e com suporte a TTL por entrada.\n *\n * @example\n * ```ts\n * import { Cache } from \"rust-node-cache\";\n *\n * const cache = new Cache();\n * cache.set(\"user:1\", { id: 1, name: \"Roberto\" });\n * cache.get<{ id: number; name: string }>(\"user:1\"); // { id: 1, name: \"Roberto\" }\n * ```\n */\nexport class Cache {\n  /** Instância da classe nativa (Rust). */\n  private readonly native: native.Cache;\n\n  constructor(options: CacheOptions = {}) {\n    // Só repassamos um objeto de opções ao Rust quando há algo relevante.\n    const hasOptions =\n      options.maxSize !== undefined ||\n      options.evictionPolicy !== undefined ||\n      options.cleanupIntervalSeconds !== undefined;\n    this.native = hasOptions\n      ? new native.Cache({\n          maxSize: options.maxSize,\n          evictionPolicy: options.evictionPolicy,\n          cleanupIntervalSeconds: options.cleanupIntervalSeconds,\n        })\n      : new native.Cache();\n  }\n\n  /** A política de evicção ativa: `\"reject\"` ou `\"lru\"`. */\n  get evictionPolicy(): EvictionPolicy {\n    return this.native.evictionPolicy as EvictionPolicy;\n  }\n\n  /**\n   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.\n   *\n   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.\n   */\n  set<T>(key: string, value: T, options?: SetOptions): boolean {\n    return this.native.set(key, value as unknown as object, options);\n  }\n\n  /**\n   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.\n   *\n   * @returns o valor desserializado, ou `null` se ausente/expirado.\n   */\n  get<T = unknown>(key: string): T | null {\n    const value = this.native.get(key);\n    return value === null || value === undefined ? null : (value as T);\n  }\n\n  /** Remove uma chave. Retorna `true` se ela existia. */\n  delete(key: string): boolean {\n    return this.native.delete(key);\n  }\n\n  /** Indica se a chave existe e está válida (não expirada). */\n  exists(key: string): boolean {\n    return this.native.exists(key);\n  }\n\n  /** Esvazia o cache (não zera os contadores históricos de `stats`). */\n  clear(): void {\n    this.native.clear();\n  }\n\n  /** Número de chaves armazenadas no momento. */\n  size(): number {\n    return this.native.size();\n  }\n\n  /**\n   * Varre e remove todas as entradas expiradas de uma só vez.\n   *\n   * @returns quantas entradas foram removidas.\n   */\n  cleanupExpired(): number {\n    return this.native.cleanupExpired();\n  }\n\n  /** Retorna as estatísticas acumuladas + o tamanho atual. */\n  stats(): CacheStats {\n    return this.native.stats();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,eAAAA;AAAA;AAAA;AAiBA,aAAwB;AA8DjB,IAAMA,SAAN,MAAY;AAAA,EAIjB,YAAY,UAAwB,CAAC,GAAG;AAEtC,UAAM,aACJ,QAAQ,YAAY,UACpB,QAAQ,mBAAmB,UAC3B,QAAQ,2BAA2B;AACrC,SAAK,SAAS,aACV,IAAW,aAAM;AAAA,MACf,SAAS,QAAQ;AAAA,MACjB,gBAAgB,QAAQ;AAAA,MACxB,wBAAwB,QAAQ;AAAA,IAClC,CAAC,IACD,IAAW,aAAM;AAAA,EACvB;AAAA;AAAA,EAGA,IAAI,iBAAiC;AACnC,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAa,OAAU,SAA+B;AAC3D,WAAO,KAAK,OAAO,IAAI,KAAK,OAA4B,OAAO;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAiB,KAAuB;AACtC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,WAAO,UAAU,QAAQ,UAAU,SAAY,OAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAyB;AACvB,WAAO,KAAK,OAAO,eAAe;AAAA,EACpC;AAAA;AAAA,EAGA,QAAoB;AAClB,WAAO,KAAK,OAAO,MAAM;AAAA,EAC3B;AACF;","names":["Cache"]}
+{"version":3,"sources":["../js/index.ts"],"sourcesContent":["/**\n * rust-node-cache — public API (TypeScript).\n *\n * \"Ultra-fast in-memory cache powered by Rust.\"\n *\n * This layer is a thin, typed wrapper over the native `Cache` class generated\n * by Rust/napi-rs. Why wrap it instead of re-exporting it directly?\n *  - it allows ergonomic **generics**: `cache.get<User>(\"user:1\")`;\n *  - it normalizes `undefined`/`null` so a miss always returns `null`;\n *  - it gives one place for the JSDoc and for evolving the API without breaking the Rust core.\n *\n * The cost is one extra function call per operation — negligible next to the\n * real work (serialization + DashMap access) done in Rust.\n */\n\n// Namespace import: works the same in CommonJS and ESM when consuming the native\n// addon (a CJS module generated by napi-rs).\nimport * as native from \"../binding.js\";\n\n/** Eviction strategy when `maxSize` is reached. */\nexport type EvictionPolicy = \"reject\" | \"lru\";\n\n/** Cache constructor options. */\nexport interface CacheOptions {\n  /**\n   * Maximum number of keys. What happens when it is reached depends on\n   * `evictionPolicy`. No value => unlimited cache.\n   */\n  maxSize?: number;\n  /**\n   * Policy when `maxSize` is reached on a **new** key:\n   * - `\"reject\"` (default): `set` returns `false` (overwriting still works);\n   * - `\"lru\"`: removes the least recently used entry and goes on.\n   */\n  evictionPolicy?: EvictionPolicy;\n  /**\n   * When set (> 0), starts a thread that sweeps expired entries every N\n   * seconds (background expiration, on top of the lazy one on access).\n   */\n  cleanupIntervalSeconds?: number;\n}\n\n/** Per-write options. */\nexport interface SetOptions {\n  /** Time to live in seconds. Absent => the entry does not expire by time. */\n  ttlSeconds?: number;\n}\n\n/** Accumulated cache statistics (plus the current size). */\nexport interface CacheStats {\n  /** Reads that found a valid entry. */\n  hits: number;\n  /** Reads without a valid key (missing or expired). */\n  misses: number;\n  /** Total writes (`set`). */\n  sets: number;\n  /** Total explicit removals (`delete`). */\n  deletes: number;\n  /** Total entries removed by expiration. */\n  expired: number;\n  /** Total entries removed by eviction (LRU policy when `maxSize` is reached). */\n  evicted: number;\n  /** Number of keys stored right now. */\n  size: number;\n}\n\n/**\n * In-memory cache with a Rust core (DashMap + atomic counters). Thread-safe,\n * with an optional TTL per entry.\n *\n * @example\n * ```ts\n * import { Cache } from \"rust-node-cache\";\n *\n * const cache = new Cache();\n * cache.set(\"user:1\", { id: 1, name: \"Roberto\" });\n * cache.get<{ id: number; name: string }>(\"user:1\"); // { id: 1, name: \"Roberto\" }\n * ```\n */\nexport class Cache {\n  /** Instance of the native (Rust) class. */\n  private readonly native: native.Cache;\n\n  constructor(options: CacheOptions = {}) {\n    // An options object is passed to Rust only when it carries something.\n    const hasOptions =\n      options.maxSize !== undefined ||\n      options.evictionPolicy !== undefined ||\n      options.cleanupIntervalSeconds !== undefined;\n    this.native = hasOptions\n      ? new native.Cache({\n          maxSize: options.maxSize,\n          evictionPolicy: options.evictionPolicy,\n          cleanupIntervalSeconds: options.cleanupIntervalSeconds,\n        })\n      : new native.Cache();\n  }\n\n  /** The active eviction policy: `\"reject\"` or `\"lru\"`. */\n  get evictionPolicy(): EvictionPolicy {\n    return this.native.evictionPolicy as EvictionPolicy;\n  }\n\n  /**\n   * Stores (or overwrites) a value. The value is serialized as JSON in the core.\n   *\n   * @returns `true` on success; `false` if `maxSize` was reached and the key is new.\n   */\n  set<T>(key: string, value: T, options?: SetOptions): boolean {\n    return this.native.set(key, value as unknown as object, options);\n  }\n\n  /**\n   * Reads a value. Applies lazy expiration: expired keys count as a miss.\n   *\n   * @returns the deserialized value, or `null` if missing or expired.\n   */\n  get<T = unknown>(key: string): T | null {\n    const value = this.native.get(key);\n    return value === null || value === undefined ? null : (value as T);\n  }\n\n  /** Removes a key. Returns `true` if it existed. */\n  delete(key: string): boolean {\n    return this.native.delete(key);\n  }\n\n  /** Whether the key exists and is still valid (not expired). */\n  exists(key: string): boolean {\n    return this.native.exists(key);\n  }\n\n  /** Empties the cache (does not reset the historical `stats` counters). */\n  clear(): void {\n    this.native.clear();\n  }\n\n  /** Number of keys currently stored. */\n  size(): number {\n    return this.native.size();\n  }\n\n  /**\n   * Sweeps and removes every expired entry at once.\n   *\n   * @returns how many entries were removed.\n   */\n  cleanupExpired(): number {\n    return this.native.cleanupExpired();\n  }\n\n  /** Returns the accumulated statistics + the current size. */\n  stats(): CacheStats {\n    return this.native.stats();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,eAAAA;AAAA;AAAA;AAiBA,aAAwB;AA8DjB,IAAMA,SAAN,MAAY;AAAA,EAIjB,YAAY,UAAwB,CAAC,GAAG;AAEtC,UAAM,aACJ,QAAQ,YAAY,UACpB,QAAQ,mBAAmB,UAC3B,QAAQ,2BAA2B;AACrC,SAAK,SAAS,aACV,IAAW,aAAM;AAAA,MACf,SAAS,QAAQ;AAAA,MACjB,gBAAgB,QAAQ;AAAA,MACxB,wBAAwB,QAAQ;AAAA,IAClC,CAAC,IACD,IAAW,aAAM;AAAA,EACvB;AAAA;AAAA,EAGA,IAAI,iBAAiC;AACnC,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAa,OAAU,SAA+B;AAC3D,WAAO,KAAK,OAAO,IAAI,KAAK,OAA4B,OAAO;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAiB,KAAuB;AACtC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,WAAO,UAAU,QAAQ,UAAU,SAAY,OAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAyB;AACvB,WAAO,KAAK,OAAO,eAAe;AAAA,EACpC;AAAA;AAAA,EAGA,QAAoB;AAClB,WAAO,KAAK,OAAO,MAAM;AAAA,EAC3B;AACF;","names":["Cache"]}

package/dist/index.mjs

@@ -9,52 +9,52 @@ var Cache2 = class {
       cleanupIntervalSeconds: options.cleanupIntervalSeconds
     }) : new native.Cache();
   }
-  /** A política de evicção ativa: `"reject"` ou `"lru"`. */
+  /** The active eviction policy: `"reject"` or `"lru"`. */
   get evictionPolicy() {
     return this.native.evictionPolicy;
   }
   /**
-   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.
+   * Stores (or overwrites) a value. The value is serialized as JSON in the core.
    *
-   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.
+   * @returns `true` on success; `false` if `maxSize` was reached and the key is new.
    */
   set(key, value, options) {
     return this.native.set(key, value, options);
   }
   /**
-   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.
+   * Reads a value. Applies lazy expiration: expired keys count as a miss.
    *
-   * @returns o valor desserializado, ou `null` se ausente/expirado.
+   * @returns the deserialized value, or `null` if missing or expired.
    */
   get(key) {
     const value = this.native.get(key);
     return value === null || value === void 0 ? null : value;
   }
-  /** Remove uma chave. Retorna `true` se ela existia. */
+  /** Removes a key. Returns `true` if it existed. */
   delete(key) {
     return this.native.delete(key);
   }
-  /** Indica se a chave existe e está válida (não expirada). */
+  /** Whether the key exists and is still valid (not expired). */
   exists(key) {
     return this.native.exists(key);
   }
-  /** Esvazia o cache (não zera os contadores históricos de `stats`). */
+  /** Empties the cache (does not reset the historical `stats` counters). */
   clear() {
     this.native.clear();
   }
-  /** Número de chaves armazenadas no momento. */
+  /** Number of keys currently stored. */
   size() {
     return this.native.size();
   }
   /**
-   * Varre e remove todas as entradas expiradas de uma só vez.
+   * Sweeps and removes every expired entry at once.
    *
-   * @returns quantas entradas foram removidas.
+   * @returns how many entries were removed.
    */
   cleanupExpired() {
     return this.native.cleanupExpired();
   }
-  /** Retorna as estatísticas acumuladas + o tamanho atual. */
+  /** Returns the accumulated statistics + the current size. */
   stats() {
     return this.native.stats();
   }

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/index.ts"],"sourcesContent":["/**\n * rust-node-cache — API pública (TypeScript).\n *\n * \"Ultra-fast in-memory cache powered by Rust.\"\n *\n * Esta camada é um wrapper fino e tipado sobre a classe `Cache` nativa gerada\n * pelo Rust/napi-rs. Por que envolver em vez de re-exportar direto?\n *  - permite **genéricos** ergonômicos: `cache.get<User>(\"user:1\")`;\n *  - normaliza `undefined`/`null` para sempre devolver `null` num miss;\n *  - dá um único lugar para JSDoc e para evoluir a API sem quebrar o core Rust.\n *\n * O custo é uma chamada de função extra por operação — desprezível frente ao\n * trabalho real (serialização + acesso ao DashMap) que acontece no Rust.\n */\n\n// Namespace import: funciona igual em CommonJS e ESM ao consumir o addon nativo\n// (que é um módulo CJS gerado pelo napi-rs).\nimport * as native from \"../binding.js\";\n\n/** Estratégia de evicção quando `maxSize` é atingido. */\nexport type EvictionPolicy = \"reject\" | \"lru\";\n\n/** Opções do construtor do cache. */\nexport interface CacheOptions {\n  /**\n   * Limite máximo de chaves. O que acontece ao atingir depende de\n   * `evictionPolicy`. Sem valor => cache ilimitado.\n   */\n  maxSize?: number;\n  /**\n   * Política ao atingir `maxSize` numa chave **nova**:\n   * - `\"reject\"` (padrão): `set` retorna `false` (sobrescrever continua ok);\n   * - `\"lru\"`: remove a entrada menos recentemente usada e prossegue.\n   */\n  evictionPolicy?: EvictionPolicy;\n  /**\n   * Se definido (> 0), liga uma thread que varre entradas expiradas a cada\n   * N segundos (expiração em background, além da preguiçosa por acesso).\n   */\n  cleanupIntervalSeconds?: number;\n}\n\n/** Opções por operação de escrita. */\nexport interface SetOptions {\n  /** Tempo de vida em segundos. Ausente => a entrada não expira por tempo. */\n  ttlSeconds?: number;\n}\n\n/** Estatísticas acumuladas do cache (mais o tamanho atual). */\nexport interface CacheStats {\n  /** Leituras que encontraram uma entrada válida. */\n  hits: number;\n  /** Leituras sem chave válida (ausente ou expirada). */\n  misses: number;\n  /** Total de escritas (`set`). */\n  sets: number;\n  /** Total de remoções explícitas (`delete`). */\n  deletes: number;\n  /** Total de entradas removidas por expiração. */\n  expired: number;\n  /** Total de entradas removidas por evicção (política LRU ao atingir `maxSize`). */\n  evicted: number;\n  /** Número de chaves armazenadas agora. */\n  size: number;\n}\n\n/**\n * Cache em memória ultrarrápido com núcleo em Rust (DashMap + contadores\n * atômicos). Thread-safe e com suporte a TTL por entrada.\n *\n * @example\n * ```ts\n * import { Cache } from \"rust-node-cache\";\n *\n * const cache = new Cache();\n * cache.set(\"user:1\", { id: 1, name: \"Roberto\" });\n * cache.get<{ id: number; name: string }>(\"user:1\"); // { id: 1, name: \"Roberto\" }\n * ```\n */\nexport class Cache {\n  /** Instância da classe nativa (Rust). */\n  private readonly native: native.Cache;\n\n  constructor(options: CacheOptions = {}) {\n    // Só repassamos um objeto de opções ao Rust quando há algo relevante.\n    const hasOptions =\n      options.maxSize !== undefined ||\n      options.evictionPolicy !== undefined ||\n      options.cleanupIntervalSeconds !== undefined;\n    this.native = hasOptions\n      ? new native.Cache({\n          maxSize: options.maxSize,\n          evictionPolicy: options.evictionPolicy,\n          cleanupIntervalSeconds: options.cleanupIntervalSeconds,\n        })\n      : new native.Cache();\n  }\n\n  /** A política de evicção ativa: `\"reject\"` ou `\"lru\"`. */\n  get evictionPolicy(): EvictionPolicy {\n    return this.native.evictionPolicy as EvictionPolicy;\n  }\n\n  /**\n   * Armazena (ou sobrescreve) um valor. O valor é serializado como JSON no core.\n   *\n   * @returns `true` em sucesso; `false` se `maxSize` foi atingido e a chave é nova.\n   */\n  set<T>(key: string, value: T, options?: SetOptions): boolean {\n    return this.native.set(key, value as unknown as object, options);\n  }\n\n  /**\n   * Lê um valor. Aplica expiração preguiçosa: chaves vencidas contam como miss.\n   *\n   * @returns o valor desserializado, ou `null` se ausente/expirado.\n   */\n  get<T = unknown>(key: string): T | null {\n    const value = this.native.get(key);\n    return value === null || value === undefined ? null : (value as T);\n  }\n\n  /** Remove uma chave. Retorna `true` se ela existia. */\n  delete(key: string): boolean {\n    return this.native.delete(key);\n  }\n\n  /** Indica se a chave existe e está válida (não expirada). */\n  exists(key: string): boolean {\n    return this.native.exists(key);\n  }\n\n  /** Esvazia o cache (não zera os contadores históricos de `stats`). */\n  clear(): void {\n    this.native.clear();\n  }\n\n  /** Número de chaves armazenadas no momento. */\n  size(): number {\n    return this.native.size();\n  }\n\n  /**\n   * Varre e remove todas as entradas expiradas de uma só vez.\n   *\n   * @returns quantas entradas foram removidas.\n   */\n  cleanupExpired(): number {\n    return this.native.cleanupExpired();\n  }\n\n  /** Retorna as estatísticas acumuladas + o tamanho atual. */\n  stats(): CacheStats {\n    return this.native.stats();\n  }\n}\n"],"mappings":";AAiBA,YAAY,YAAY;AA8DjB,IAAMA,SAAN,MAAY;AAAA,EAIjB,YAAY,UAAwB,CAAC,GAAG;AAEtC,UAAM,aACJ,QAAQ,YAAY,UACpB,QAAQ,mBAAmB,UAC3B,QAAQ,2BAA2B;AACrC,SAAK,SAAS,aACV,IAAW,aAAM;AAAA,MACf,SAAS,QAAQ;AAAA,MACjB,gBAAgB,QAAQ;AAAA,MACxB,wBAAwB,QAAQ;AAAA,IAClC,CAAC,IACD,IAAW,aAAM;AAAA,EACvB;AAAA;AAAA,EAGA,IAAI,iBAAiC;AACnC,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAa,OAAU,SAA+B;AAC3D,WAAO,KAAK,OAAO,IAAI,KAAK,OAA4B,OAAO;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAiB,KAAuB;AACtC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,WAAO,UAAU,QAAQ,UAAU,SAAY,OAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAyB;AACvB,WAAO,KAAK,OAAO,eAAe;AAAA,EACpC;AAAA;AAAA,EAGA,QAAoB;AAClB,WAAO,KAAK,OAAO,MAAM;AAAA,EAC3B;AACF;","names":["Cache"]}
+{"version":3,"sources":["../js/index.ts"],"sourcesContent":["/**\n * rust-node-cache — public API (TypeScript).\n *\n * \"Ultra-fast in-memory cache powered by Rust.\"\n *\n * This layer is a thin, typed wrapper over the native `Cache` class generated\n * by Rust/napi-rs. Why wrap it instead of re-exporting it directly?\n *  - it allows ergonomic **generics**: `cache.get<User>(\"user:1\")`;\n *  - it normalizes `undefined`/`null` so a miss always returns `null`;\n *  - it gives one place for the JSDoc and for evolving the API without breaking the Rust core.\n *\n * The cost is one extra function call per operation — negligible next to the\n * real work (serialization + DashMap access) done in Rust.\n */\n\n// Namespace import: works the same in CommonJS and ESM when consuming the native\n// addon (a CJS module generated by napi-rs).\nimport * as native from \"../binding.js\";\n\n/** Eviction strategy when `maxSize` is reached. */\nexport type EvictionPolicy = \"reject\" | \"lru\";\n\n/** Cache constructor options. */\nexport interface CacheOptions {\n  /**\n   * Maximum number of keys. What happens when it is reached depends on\n   * `evictionPolicy`. No value => unlimited cache.\n   */\n  maxSize?: number;\n  /**\n   * Policy when `maxSize` is reached on a **new** key:\n   * - `\"reject\"` (default): `set` returns `false` (overwriting still works);\n   * - `\"lru\"`: removes the least recently used entry and goes on.\n   */\n  evictionPolicy?: EvictionPolicy;\n  /**\n   * When set (> 0), starts a thread that sweeps expired entries every N\n   * seconds (background expiration, on top of the lazy one on access).\n   */\n  cleanupIntervalSeconds?: number;\n}\n\n/** Per-write options. */\nexport interface SetOptions {\n  /** Time to live in seconds. Absent => the entry does not expire by time. */\n  ttlSeconds?: number;\n}\n\n/** Accumulated cache statistics (plus the current size). */\nexport interface CacheStats {\n  /** Reads that found a valid entry. */\n  hits: number;\n  /** Reads without a valid key (missing or expired). */\n  misses: number;\n  /** Total writes (`set`). */\n  sets: number;\n  /** Total explicit removals (`delete`). */\n  deletes: number;\n  /** Total entries removed by expiration. */\n  expired: number;\n  /** Total entries removed by eviction (LRU policy when `maxSize` is reached). */\n  evicted: number;\n  /** Number of keys stored right now. */\n  size: number;\n}\n\n/**\n * In-memory cache with a Rust core (DashMap + atomic counters). Thread-safe,\n * with an optional TTL per entry.\n *\n * @example\n * ```ts\n * import { Cache } from \"rust-node-cache\";\n *\n * const cache = new Cache();\n * cache.set(\"user:1\", { id: 1, name: \"Roberto\" });\n * cache.get<{ id: number; name: string }>(\"user:1\"); // { id: 1, name: \"Roberto\" }\n * ```\n */\nexport class Cache {\n  /** Instance of the native (Rust) class. */\n  private readonly native: native.Cache;\n\n  constructor(options: CacheOptions = {}) {\n    // An options object is passed to Rust only when it carries something.\n    const hasOptions =\n      options.maxSize !== undefined ||\n      options.evictionPolicy !== undefined ||\n      options.cleanupIntervalSeconds !== undefined;\n    this.native = hasOptions\n      ? new native.Cache({\n          maxSize: options.maxSize,\n          evictionPolicy: options.evictionPolicy,\n          cleanupIntervalSeconds: options.cleanupIntervalSeconds,\n        })\n      : new native.Cache();\n  }\n\n  /** The active eviction policy: `\"reject\"` or `\"lru\"`. */\n  get evictionPolicy(): EvictionPolicy {\n    return this.native.evictionPolicy as EvictionPolicy;\n  }\n\n  /**\n   * Stores (or overwrites) a value. The value is serialized as JSON in the core.\n   *\n   * @returns `true` on success; `false` if `maxSize` was reached and the key is new.\n   */\n  set<T>(key: string, value: T, options?: SetOptions): boolean {\n    return this.native.set(key, value as unknown as object, options);\n  }\n\n  /**\n   * Reads a value. Applies lazy expiration: expired keys count as a miss.\n   *\n   * @returns the deserialized value, or `null` if missing or expired.\n   */\n  get<T = unknown>(key: string): T | null {\n    const value = this.native.get(key);\n    return value === null || value === undefined ? null : (value as T);\n  }\n\n  /** Removes a key. Returns `true` if it existed. */\n  delete(key: string): boolean {\n    return this.native.delete(key);\n  }\n\n  /** Whether the key exists and is still valid (not expired). */\n  exists(key: string): boolean {\n    return this.native.exists(key);\n  }\n\n  /** Empties the cache (does not reset the historical `stats` counters). */\n  clear(): void {\n    this.native.clear();\n  }\n\n  /** Number of keys currently stored. */\n  size(): number {\n    return this.native.size();\n  }\n\n  /**\n   * Sweeps and removes every expired entry at once.\n   *\n   * @returns how many entries were removed.\n   */\n  cleanupExpired(): number {\n    return this.native.cleanupExpired();\n  }\n\n  /** Returns the accumulated statistics + the current size. */\n  stats(): CacheStats {\n    return this.native.stats();\n  }\n}\n"],"mappings":";AAiBA,YAAY,YAAY;AA8DjB,IAAMA,SAAN,MAAY;AAAA,EAIjB,YAAY,UAAwB,CAAC,GAAG;AAEtC,UAAM,aACJ,QAAQ,YAAY,UACpB,QAAQ,mBAAmB,UAC3B,QAAQ,2BAA2B;AACrC,SAAK,SAAS,aACV,IAAW,aAAM;AAAA,MACf,SAAS,QAAQ;AAAA,MACjB,gBAAgB,QAAQ;AAAA,MACxB,wBAAwB,QAAQ;AAAA,IAClC,CAAC,IACD,IAAW,aAAM;AAAA,EACvB;AAAA;AAAA,EAGA,IAAI,iBAAiC;AACnC,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAa,OAAU,SAA+B;AAC3D,WAAO,KAAK,OAAO,IAAI,KAAK,OAA4B,OAAO;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAiB,KAAuB;AACtC,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,WAAO,UAAU,QAAQ,UAAU,SAAY,OAAQ;AAAA,EACzD;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAO,KAAsB;AAC3B,WAAO,KAAK,OAAO,OAAO,GAAG;AAAA,EAC/B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO,KAAK;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAyB;AACvB,WAAO,KAAK,OAAO,eAAe;AAAA,EACpC;AAAA;AAAA,EAGA,QAAoB;AAClB,WAAO,KAAK,OAAO,MAAM;AAAA,EAC3B;AACF;","names":["Cache"]}

package/dist/nestjs.d.mts

@@ -3,36 +3,36 @@ import { Observable } from 'rxjs';
 import { Cache } from './index.mjs';
 
 /**
- * Integração com NestJS: interceptor de cache de respostas.
+ * NestJS integration: a response caching interceptor.
  *
- * Uso:
+ * Usage:
  *   import { Cache } from "rust-node-cache";
  *   import { CacheInterceptor } from "rust-node-cache/nestjs";
  *
  *   const cache = new Cache();
  *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));
  *
- * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime
- * do Nest aqui — o pacote não força o Nest como dependência. A única dependência
- * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).
+ * `@nestjs/common` is imported with `import type`, so there is NO runtime import
+ * of Nest here — the package does not force Nest as a dependency. The only runtime
+ * dependencies are RxJS's `of`/`tap` operators (present in any Nest app).
  */
 
 interface CacheInterceptorOptions {
-    /** Instância de cache a usar. */
+    /** Cache instance to use. */
     cache: Cache;
-    /** TTL aplicado às respostas guardadas (em segundos). */
+    /** TTL applied to stored responses (in seconds). */
     ttlSeconds?: number;
-    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    /** HTTP methods eligible for caching. Default: `["GET"]`. */
     methods?: string[];
-    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    /** Builds the cache key from the request. Default: `METHOD:url`. */
     keyGenerator?: (req: {
         method: string;
         url: string;
     }) => string;
 }
 /**
- * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,
- * devolve o valor do cache sem executar o handler.
+ * NestJS interceptor that caches the value returned by handlers. On a HIT, it
+ * returns the cached value without running the handler.
  */
 declare class CacheInterceptor implements NestInterceptor {
     private readonly cache;

package/dist/nestjs.d.ts

@@ -3,36 +3,36 @@ import { Observable } from 'rxjs';
 import { Cache } from './index.js';
 
 /**
- * Integração com NestJS: interceptor de cache de respostas.
+ * NestJS integration: a response caching interceptor.
  *
- * Uso:
+ * Usage:
  *   import { Cache } from "rust-node-cache";
  *   import { CacheInterceptor } from "rust-node-cache/nestjs";
  *
  *   const cache = new Cache();
  *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));
  *
- * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime
- * do Nest aqui — o pacote não força o Nest como dependência. A única dependência
- * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).
+ * `@nestjs/common` is imported with `import type`, so there is NO runtime import
+ * of Nest here — the package does not force Nest as a dependency. The only runtime
+ * dependencies are RxJS's `of`/`tap` operators (present in any Nest app).
  */
 
 interface CacheInterceptorOptions {
-    /** Instância de cache a usar. */
+    /** Cache instance to use. */
     cache: Cache;
-    /** TTL aplicado às respostas guardadas (em segundos). */
+    /** TTL applied to stored responses (in seconds). */
     ttlSeconds?: number;
-    /** Métodos HTTP elegíveis para cache. Padrão: `["GET"]`. */
+    /** HTTP methods eligible for caching. Default: `["GET"]`. */
     methods?: string[];
-    /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */
+    /** Builds the cache key from the request. Default: `METHOD:url`. */
     keyGenerator?: (req: {
         method: string;
         url: string;
     }) => string;
 }
 /**
- * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,
- * devolve o valor do cache sem executar o handler.
+ * NestJS interceptor that caches the value returned by handlers. On a HIT, it
+ * returns the cached value without running the handler.
  */
 declare class CacheInterceptor implements NestInterceptor {
     private readonly cache;

package/dist/nestjs.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/nestjs.ts"],"sourcesContent":["/**\n * Integração com NestJS: interceptor de cache de respostas.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { CacheInterceptor } from \"rust-node-cache/nestjs\";\n *\n *   const cache = new Cache();\n *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));\n *\n * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime\n * do Nest aqui — o pacote não força o Nest como dependência. A única dependência\n * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).\n */\n\nimport type {\n  CallHandler,\n  ExecutionContext,\n  NestInterceptor,\n} from \"@nestjs/common\";\nimport type { Observable } from \"rxjs\";\nimport { of, tap } from \"rxjs\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheInterceptorOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: { method: string; url: string }) => string;\n}\n\n/**\n * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,\n * devolve o valor do cache sem executar o handler.\n */\nexport class CacheInterceptor implements NestInterceptor {\n  private readonly cache: Cache;\n  private readonly ttlSeconds?: number;\n  private readonly methods: string[];\n  private readonly keyGenerator: (req: {\n    method: string;\n    url: string;\n  }) => string;\n\n  constructor(options: CacheInterceptorOptions) {\n    this.cache = options.cache;\n    this.ttlSeconds = options.ttlSeconds;\n    this.methods = options.methods ?? [\"GET\"];\n    this.keyGenerator =\n      options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);\n  }\n\n  intercept(\n    context: ExecutionContext,\n    next: CallHandler,\n  ): Observable<unknown> {\n    const req = context.switchToHttp().getRequest<{\n      method: string;\n      url: string;\n    }>();\n\n    if (!this.methods.includes(req.method)) {\n      return next.handle();\n    }\n\n    const key = this.keyGenerator(req);\n    const cached = this.cache.get(key);\n    if (cached !== null) {\n      return of(cached);\n    }\n\n    return next.handle().pipe(\n      tap((body) => {\n        if (body !== undefined && body !== null) {\n          this.cache.set(\n            key,\n            body,\n            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : undefined,\n          );\n        }\n      }),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBA,kBAAwB;AAkBjB,IAAM,mBAAN,MAAkD;AAAA,EASvD,YAAY,SAAkC;AAC5C,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,UAAU,QAAQ,WAAW,CAAC,KAAK;AACxC,SAAK,eACH,QAAQ,iBAAiB,CAAC,QAAQ,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAAA,EAC9D;AAAA,EAEA,UACE,SACA,MACqB;AACrB,UAAM,MAAM,QAAQ,aAAa,EAAE,WAGhC;AAEH,QAAI,CAAC,KAAK,QAAQ,SAAS,IAAI,MAAM,GAAG;AACtC,aAAO,KAAK,OAAO;AAAA,IACrB;AAEA,UAAM,MAAM,KAAK,aAAa,GAAG;AACjC,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,WAAW,MAAM;AACnB,iBAAO,gBAAG,MAAM;AAAA,IAClB;AAEA,WAAO,KAAK,OAAO,EAAE;AAAA,UACnB,iBAAI,CAAC,SAAS;AACZ,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC,eAAK,MAAM;AAAA,YACT;AAAA,YACA;AAAA,YACA,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI;AAAA,UACtD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../js/nestjs.ts"],"sourcesContent":["/**\n * NestJS integration: a response caching interceptor.\n *\n * Usage:\n *   import { Cache } from \"rust-node-cache\";\n *   import { CacheInterceptor } from \"rust-node-cache/nestjs\";\n *\n *   const cache = new Cache();\n *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));\n *\n * `@nestjs/common` is imported with `import type`, so there is NO runtime import\n * of Nest here — the package does not force Nest as a dependency. The only runtime\n * dependencies are RxJS's `of`/`tap` operators (present in any Nest app).\n */\n\nimport type {\n  CallHandler,\n  ExecutionContext,\n  NestInterceptor,\n} from \"@nestjs/common\";\nimport type { Observable } from \"rxjs\";\nimport { of, tap } from \"rxjs\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheInterceptorOptions {\n  /** Cache instance to use. */\n  cache: Cache;\n  /** TTL applied to stored responses (in seconds). */\n  ttlSeconds?: number;\n  /** HTTP methods eligible for caching. Default: `[\"GET\"]`. */\n  methods?: string[];\n  /** Builds the cache key from the request. Default: `METHOD:url`. */\n  keyGenerator?: (req: { method: string; url: string }) => string;\n}\n\n/**\n * NestJS interceptor that caches the value returned by handlers. On a HIT, it\n * returns the cached value without running the handler.\n */\nexport class CacheInterceptor implements NestInterceptor {\n  private readonly cache: Cache;\n  private readonly ttlSeconds?: number;\n  private readonly methods: string[];\n  private readonly keyGenerator: (req: {\n    method: string;\n    url: string;\n  }) => string;\n\n  constructor(options: CacheInterceptorOptions) {\n    this.cache = options.cache;\n    this.ttlSeconds = options.ttlSeconds;\n    this.methods = options.methods ?? [\"GET\"];\n    this.keyGenerator =\n      options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);\n  }\n\n  intercept(\n    context: ExecutionContext,\n    next: CallHandler,\n  ): Observable<unknown> {\n    const req = context.switchToHttp().getRequest<{\n      method: string;\n      url: string;\n    }>();\n\n    if (!this.methods.includes(req.method)) {\n      return next.handle();\n    }\n\n    const key = this.keyGenerator(req);\n    const cached = this.cache.get(key);\n    if (cached !== null) {\n      return of(cached);\n    }\n\n    return next.handle().pipe(\n      tap((body) => {\n        if (body !== undefined && body !== null) {\n          this.cache.set(\n            key,\n            body,\n            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : undefined,\n          );\n        }\n      }),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBA,kBAAwB;AAkBjB,IAAM,mBAAN,MAAkD;AAAA,EASvD,YAAY,SAAkC;AAC5C,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,UAAU,QAAQ,WAAW,CAAC,KAAK;AACxC,SAAK,eACH,QAAQ,iBAAiB,CAAC,QAAQ,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAAA,EAC9D;AAAA,EAEA,UACE,SACA,MACqB;AACrB,UAAM,MAAM,QAAQ,aAAa,EAAE,WAGhC;AAEH,QAAI,CAAC,KAAK,QAAQ,SAAS,IAAI,MAAM,GAAG;AACtC,aAAO,KAAK,OAAO;AAAA,IACrB;AAEA,UAAM,MAAM,KAAK,aAAa,GAAG;AACjC,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,WAAW,MAAM;AACnB,iBAAO,gBAAG,MAAM;AAAA,IAClB;AAEA,WAAO,KAAK,OAAO,EAAE;AAAA,UACnB,iBAAI,CAAC,SAAS;AACZ,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC,eAAK,MAAM;AAAA,YACT;AAAA,YACA;AAAA,YACA,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI;AAAA,UACtD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/nestjs.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../js/nestjs.ts"],"sourcesContent":["/**\n * Integração com NestJS: interceptor de cache de respostas.\n *\n * Uso:\n *   import { Cache } from \"rust-node-cache\";\n *   import { CacheInterceptor } from \"rust-node-cache/nestjs\";\n *\n *   const cache = new Cache();\n *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));\n *\n * Usamos `import type` para `@nestjs/common`, ou seja, NÃO há import em runtime\n * do Nest aqui — o pacote não força o Nest como dependência. A única dependência\n * de runtime são os operadores `of`/`tap` do RxJS (presentes em qualquer app Nest).\n */\n\nimport type {\n  CallHandler,\n  ExecutionContext,\n  NestInterceptor,\n} from \"@nestjs/common\";\nimport type { Observable } from \"rxjs\";\nimport { of, tap } from \"rxjs\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheInterceptorOptions {\n  /** Instância de cache a usar. */\n  cache: Cache;\n  /** TTL aplicado às respostas guardadas (em segundos). */\n  ttlSeconds?: number;\n  /** Métodos HTTP elegíveis para cache. Padrão: `[\"GET\"]`. */\n  methods?: string[];\n  /** Gera a chave de cache a partir da requisição. Padrão: `METHOD:url`. */\n  keyGenerator?: (req: { method: string; url: string }) => string;\n}\n\n/**\n * Interceptor NestJS que cacheia o valor retornado pelos handlers. Num HIT,\n * devolve o valor do cache sem executar o handler.\n */\nexport class CacheInterceptor implements NestInterceptor {\n  private readonly cache: Cache;\n  private readonly ttlSeconds?: number;\n  private readonly methods: string[];\n  private readonly keyGenerator: (req: {\n    method: string;\n    url: string;\n  }) => string;\n\n  constructor(options: CacheInterceptorOptions) {\n    this.cache = options.cache;\n    this.ttlSeconds = options.ttlSeconds;\n    this.methods = options.methods ?? [\"GET\"];\n    this.keyGenerator =\n      options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);\n  }\n\n  intercept(\n    context: ExecutionContext,\n    next: CallHandler,\n  ): Observable<unknown> {\n    const req = context.switchToHttp().getRequest<{\n      method: string;\n      url: string;\n    }>();\n\n    if (!this.methods.includes(req.method)) {\n      return next.handle();\n    }\n\n    const key = this.keyGenerator(req);\n    const cached = this.cache.get(key);\n    if (cached !== null) {\n      return of(cached);\n    }\n\n    return next.handle().pipe(\n      tap((body) => {\n        if (body !== undefined && body !== null) {\n          this.cache.set(\n            key,\n            body,\n            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : undefined,\n          );\n        }\n      }),\n    );\n  }\n}\n"],"mappings":";AAqBA,SAAS,IAAI,WAAW;AAkBjB,IAAM,mBAAN,MAAkD;AAAA,EASvD,YAAY,SAAkC;AAC5C,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,UAAU,QAAQ,WAAW,CAAC,KAAK;AACxC,SAAK,eACH,QAAQ,iBAAiB,CAAC,QAAQ,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAAA,EAC9D;AAAA,EAEA,UACE,SACA,MACqB;AACrB,UAAM,MAAM,QAAQ,aAAa,EAAE,WAGhC;AAEH,QAAI,CAAC,KAAK,QAAQ,SAAS,IAAI,MAAM,GAAG;AACtC,aAAO,KAAK,OAAO;AAAA,IACrB;AAEA,UAAM,MAAM,KAAK,aAAa,GAAG;AACjC,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,WAAW,MAAM;AACnB,aAAO,GAAG,MAAM;AAAA,IAClB;AAEA,WAAO,KAAK,OAAO,EAAE;AAAA,MACnB,IAAI,CAAC,SAAS;AACZ,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC,eAAK,MAAM;AAAA,YACT;AAAA,YACA;AAAA,YACA,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI;AAAA,UACtD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../js/nestjs.ts"],"sourcesContent":["/**\n * NestJS integration: a response caching interceptor.\n *\n * Usage:\n *   import { Cache } from \"rust-node-cache\";\n *   import { CacheInterceptor } from \"rust-node-cache/nestjs\";\n *\n *   const cache = new Cache();\n *   app.useGlobalInterceptors(new CacheInterceptor({ cache, ttlSeconds: 60 }));\n *\n * `@nestjs/common` is imported with `import type`, so there is NO runtime import\n * of Nest here — the package does not force Nest as a dependency. The only runtime\n * dependencies are RxJS's `of`/`tap` operators (present in any Nest app).\n */\n\nimport type {\n  CallHandler,\n  ExecutionContext,\n  NestInterceptor,\n} from \"@nestjs/common\";\nimport type { Observable } from \"rxjs\";\nimport { of, tap } from \"rxjs\";\nimport type { Cache } from \"./index\";\n\nexport interface CacheInterceptorOptions {\n  /** Cache instance to use. */\n  cache: Cache;\n  /** TTL applied to stored responses (in seconds). */\n  ttlSeconds?: number;\n  /** HTTP methods eligible for caching. Default: `[\"GET\"]`. */\n  methods?: string[];\n  /** Builds the cache key from the request. Default: `METHOD:url`. */\n  keyGenerator?: (req: { method: string; url: string }) => string;\n}\n\n/**\n * NestJS interceptor that caches the value returned by handlers. On a HIT, it\n * returns the cached value without running the handler.\n */\nexport class CacheInterceptor implements NestInterceptor {\n  private readonly cache: Cache;\n  private readonly ttlSeconds?: number;\n  private readonly methods: string[];\n  private readonly keyGenerator: (req: {\n    method: string;\n    url: string;\n  }) => string;\n\n  constructor(options: CacheInterceptorOptions) {\n    this.cache = options.cache;\n    this.ttlSeconds = options.ttlSeconds;\n    this.methods = options.methods ?? [\"GET\"];\n    this.keyGenerator =\n      options.keyGenerator ?? ((req) => `${req.method}:${req.url}`);\n  }\n\n  intercept(\n    context: ExecutionContext,\n    next: CallHandler,\n  ): Observable<unknown> {\n    const req = context.switchToHttp().getRequest<{\n      method: string;\n      url: string;\n    }>();\n\n    if (!this.methods.includes(req.method)) {\n      return next.handle();\n    }\n\n    const key = this.keyGenerator(req);\n    const cached = this.cache.get(key);\n    if (cached !== null) {\n      return of(cached);\n    }\n\n    return next.handle().pipe(\n      tap((body) => {\n        if (body !== undefined && body !== null) {\n          this.cache.set(\n            key,\n            body,\n            this.ttlSeconds ? { ttlSeconds: this.ttlSeconds } : undefined,\n          );\n        }\n      }),\n    );\n  }\n}\n"],"mappings":";AAqBA,SAAS,IAAI,WAAW;AAkBjB,IAAM,mBAAN,MAAkD;AAAA,EASvD,YAAY,SAAkC;AAC5C,SAAK,QAAQ,QAAQ;AACrB,SAAK,aAAa,QAAQ;AAC1B,SAAK,UAAU,QAAQ,WAAW,CAAC,KAAK;AACxC,SAAK,eACH,QAAQ,iBAAiB,CAAC,QAAQ,GAAG,IAAI,MAAM,IAAI,IAAI,GAAG;AAAA,EAC9D;AAAA,EAEA,UACE,SACA,MACqB;AACrB,UAAM,MAAM,QAAQ,aAAa,EAAE,WAGhC;AAEH,QAAI,CAAC,KAAK,QAAQ,SAAS,IAAI,MAAM,GAAG;AACtC,aAAO,KAAK,OAAO;AAAA,IACrB;AAEA,UAAM,MAAM,KAAK,aAAa,GAAG;AACjC,UAAM,SAAS,KAAK,MAAM,IAAI,GAAG;AACjC,QAAI,WAAW,MAAM;AACnB,aAAO,GAAG,MAAM;AAAA,IAClB;AAEA,WAAO,KAAK,OAAO,EAAE;AAAA,MACnB,IAAI,CAAC,SAAS;AACZ,YAAI,SAAS,UAAa,SAAS,MAAM;AACvC,eAAK,MAAM;AAAA,YACT;AAAA,YACA;AAAA,YACA,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI;AAAA,UACtD;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rust-node-cache",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Ultra-fast in-memory cache for Node.js powered by Rust.",
   "keywords": [
     "cache",
@@ -66,7 +66,9 @@
         "aarch64-apple-darwin",
         "aarch64-unknown-linux-gnu",
         "x86_64-unknown-linux-gnu",
-        "x86_64-pc-windows-msvc"
+        "x86_64-pc-windows-msvc",
+        "x86_64-unknown-linux-musl",
+        "aarch64-unknown-linux-musl"
       ]
     }
   },