@iamjulianacosta/mobx-data 1.1.0 → 1.4.0

package/README.md

@@ -1,24 +1,24 @@
-# mobx-data
+# @iamjulianacosta/mobx-data
 
 [![build](https://img.shields.io/endpoint?url=https://iamjulianacosta.github.io/mobx-data/build-badge.json)](https://github.com/IAmJulianAcosta/mobx-data)
 [![coverage](https://img.shields.io/endpoint?url=https://iamjulianacosta.github.io/mobx-data/coverage-badge.json)](https://github.com/IAmJulianAcosta/mobx-data)
 [![version](https://img.shields.io/endpoint?url=https://iamjulianacosta.github.io/mobx-data/version-badge.json)](https://github.com/IAmJulianAcosta/mobx-data/releases)
 [![license](https://img.shields.io/endpoint?url=https://iamjulianacosta.github.io/mobx-data/license-badge.json)](./LICENSE)
 
-A feature-complete port of Ember Data to MobX — framework-agnostic, TypeScript-first, fully observable.
+An Ember Data-inspired data layer for MobX applications — framework-agnostic, TypeScript-first, fully observable.
 
 ---
 
 ## Overview
 
-`mobx-data` brings the battle-tested Ember Data mental model (Identity Map, pluggable adapters/serializers, record state machines, async relationships) to any MobX application.  All state is observable; no manual invalidation or subscriptions are needed.
+`@iamjulianacosta/mobx-data` provides a structured data layer built on MobX. It brings identity-mapped records, pluggable adapters and serializers, record state machines, and async relationships to any MobX application. All state is observable; no manual invalidation or subscriptions are needed.
 
 ### Design principles
 
 - **Framework-agnostic** — works with React, Vue, Solid, or plain JS
 - **MobX-native** — every piece of state is a MobX `observable`; computed props react automatically
 - **TypeScript-first** — full generic types throughout
-- **Ember Data parity** — near 1-to-1 API mapping so Ember Data users feel at home
+- **Ember Data-inspired** — familiar API patterns for Ember Data users
 
 ---
 
@@ -26,35 +26,43 @@ A feature-complete port of Ember Data to MobX — framework-agnostic, TypeScript
 
 | Feature | Status |
 |---------|--------|
-| `Store` with Identity Map | ✅ |
-| `Model` base class + lifecycle hooks | ✅ |
-| `@attr`, `@belongsTo`, `@hasMany` decorators | ✅ |
-| Record state machine (`isNew`, `isDirty`, `isSaving`, …) | ✅ |
-| Dirty tracking & `rollbackAttributes` | ✅ |
-| `RecordArray` / `AdapterPopulatedRecordArray` | ✅ |
-| `RestAdapter` | ✅ |
-| `JsonApiAdapter` | ✅ |
-| `ODataAdapter` (v4) | ✅ |
-| `JsonSerializer` / `RestSerializer` / `JsonApiSerializer` | ✅ |
-| `EmbeddedRecordsMixin` | ✅ |
-| Async & sync `belongsTo` / `hasMany` | ✅ |
-| Inverse relationship tracking | ✅ |
-| `Snapshot` | ✅ |
-| `RequestManager` + handler chain | ✅ |
-| `FetchHandler` / `CacheHandler` | ✅ |
-| Built-in transforms (`string`, `number`, `boolean`, `date`) | ✅ |
-| `SchemaService` | ✅ |
-| `Errors` (field-level validation) | ✅ |
+| `Store` with Identity Map | Done |
+| `Model` base class + lifecycle hooks | Done |
+| `@attr`, `@belongsTo`, `@hasMany` decorators | Done |
+| Record state machine (`isNew`, `isDirty`, `isSaving`, ...) | Done |
+| Dirty tracking & `rollbackAttributes` | Done |
+| `RecordArray` / `AdapterPopulatedRecordArray` | Done |
+| `RestAdapter` | Done |
+| `JsonApiAdapter` | Done |
+| `ODataAdapter` (v4) | Done |
+| `JsonSerializer` / `RestSerializer` / `JsonApiSerializer` | Done |
+| `EmbeddedRecordsMixin` | Done |
+| Async & sync `belongsTo` / `hasMany` | Done |
+| Inverse relationship tracking | Done |
+| Polymorphic models (discriminator-based) | Done |
+| `Snapshot` | Done |
+| `RequestManager` + handler chain | Done |
+| `FetchHandler` / `CacheHandler` | Done |
+| Built-in transforms (`string`, `number`, `boolean`, `date`) | Done |
+| `SchemaService` | Done |
+| `Errors` (field-level validation) | Done |
+| `coalesceFindRequests` (batched findRecord calls) | Done |
+| `IndexedDBCache` (offline-first persistent cache) | Done |
+| MDQL query builder (`store.select()`) | Done |
 
 ---
 
 ## Installation
 
 ```bash
-pnpm add mobx-data mobx reflect-metadata tsyringe
+npm install @iamjulianacosta/mobx-data mobx reflect-metadata tsyringe
 ```
 
-Enable decorator metadata in your `tsconfig.json`:
+### Decorator compatibility
+
+This library uses TypeScript legacy decorators and `reflect-metadata`.
+
+Required `tsconfig.json` settings:
 
 ```json
 {
@@ -68,9 +76,15 @@ Enable decorator metadata in your `tsconfig.json`:
 Import `reflect-metadata` once at your application entry point:
 
 ```ts
-import 'reflect-metadata';
+import "reflect-metadata";
 ```
 
+**Compatibility notes:**
+- TypeScript 4.7+ is required
+- Only legacy decorators (`experimentalDecorators`) are supported
+- TC39 stage 3 decorators are not yet supported
+- If `reflect-metadata` is missing, the library throws a clear error at startup
+
 ---
 
 ## Quick start
@@ -78,71 +92,100 @@ import 'reflect-metadata';
 ### 1. Define models
 
 ```ts
-import { Model, attr, belongsTo, hasMany } from 'mobx-data/model';
+import { Model, attr, belongsTo, hasMany } from "@iamjulianacosta/mobx-data/model";
 
 class User extends Model {
-  static modelName = 'user';
+  static modelName = "user";
 
-  @attr('string') name!: string;
-  @attr('string') email!: string;
+  @attr("string") name!: string;
+  @attr("string") email!: string;
 
-  @hasMany('post', { async: false, inverse: 'author' })
+  @hasMany("post", { async: false, inverse: "author" })
   posts!: ManyArray<Post>;
 }
 
 class Post extends Model {
-  static modelName = 'post';
+  static modelName = "post";
 
-  @attr('string') title!: string;
-  @attr('date')   publishedAt!: Date | null;
+  @attr("string") title!: string;
+  @attr("date") publishedAt!: Date | null;
 
-  @belongsTo('user', { async: false, inverse: 'posts' })
+  @belongsTo("user", { async: false, inverse: "posts" })
   author!: User | null;
 }
 ```
 
 ### 2. Create a store
 
+The simplest way to get started:
+
+```ts
+import "reflect-metadata";
+import { createStore } from "@iamjulianacosta/mobx-data/store";
+
+const store = createStore({
+  models: [User, Post],
+});
+```
+
+This registers all models, creates a `SchemaService`, and wires up a default `RestAdapter` and `JsonSerializer`.
+
+For custom adapters or serializers:
+
+```ts
+import { createStore } from "@iamjulianacosta/mobx-data/store";
+import { JsonApiAdapter } from "@iamjulianacosta/mobx-data/json-api";
+import { JsonApiSerializer } from "@iamjulianacosta/mobx-data/json-api";
+
+const store = createStore({
+  models: [User, Post],
+  adapter: new JsonApiAdapter(),
+  serializer: new JsonApiSerializer(),
+});
+```
+
+For full control, use the manual setup:
+
 ```ts
-import 'reflect-metadata';
-import { container } from 'tsyringe';
-import { Store } from 'mobx-data/store';
-import { SchemaService } from 'mobx-data/schema';
-import { RestAdapter } from 'mobx-data/adapter';
-import { JsonSerializer } from 'mobx-data/serializer';
+import "reflect-metadata";
+import { container } from "tsyringe";
+import { Store } from "@iamjulianacosta/mobx-data/store";
+import { SchemaService } from "@iamjulianacosta/mobx-data/schema";
+import { RestAdapter } from "@iamjulianacosta/mobx-data/adapter";
+import { JsonSerializer } from "@iamjulianacosta/mobx-data/serializer";
 
 const schema = container.resolve(SchemaService);
-schema.registerModel('user', User);
-schema.registerModel('post', Post);
+schema.registerModel("user", User);
+schema.registerModel("post", Post);
 
 const store = container.resolve(Store);
 
 const adapter = new RestAdapter();
-adapter.host = 'https://api.example.com';
+adapter.host = "https://api.example.com";
 
-store.registerAdapter('application', adapter);
-store.registerSerializer('application', new JsonSerializer());
+store.registerAdapter("application", adapter);
+store.registerSerializer("application", new JsonSerializer());
 ```
 
 ### 3. Use the store
 
 ```ts
 // Find a single record
-const user = await store.findRecord('user', '1');
-console.log(user.name); // 'Alice'
+const user = await store.findRecord("user", "1");
+console.log(user.name); // "Alice"
 
 // Find all
-const users = await store.findAll('user');
+const users = await store.findAll("user");
 
 // Query
-const posts = await store.query('post', { filter: { published: true } });
+const posts = await store.query("post", { filter: { published: true } });
 
 // Create
-const post = store.createRecord('post', { title: 'Hello World' });
+const post = store.createRecord("post", { title: "Hello World" });
 await post.save();
 
 // Update
-user.name = 'Bob';
+user.name = "Bob";
 await user.save();
 
 // Delete
@@ -150,7 +193,7 @@ await post.destroyRecord();
 
 // Push raw data
 store.push({
-  data: { type: 'user', id: '2', attributes: { name: 'Carol' } }
+  data: { type: "user", id: "2", attributes: { name: "Carol" } },
 });
 ```
 
@@ -163,10 +206,12 @@ store.push({
 Standard REST conventions (`GET /users/1`, `POST /users`, `PUT /users/1`, `DELETE /users/1`).
 
 ```ts
+import { RestAdapter } from "@iamjulianacosta/mobx-data/adapter";
+
 const adapter = new RestAdapter();
-adapter.host = 'https://api.example.com';
-adapter.namespace = 'api/v2';
-adapter.headers = { Authorization: 'Bearer …' };
+adapter.host = "https://api.example.com";
+adapter.namespace = "api/v2";
+adapter.headers = { Authorization: "Bearer ..." };
 ```
 
 ### JsonApiAdapter
@@ -174,8 +219,10 @@ adapter.headers = { Authorization: 'Bearer …' };
 Implements the [JSON:API](https://jsonapi.org) specification, including `application/vnd.api+json` MIME type and PATCH for updates.
 
 ```ts
+import { JsonApiAdapter } from "@iamjulianacosta/mobx-data/json-api";
+
 const adapter = new JsonApiAdapter();
-adapter.host = 'https://api.example.com';
+adapter.host = "https://api.example.com";
 ```
 
 ### ODataAdapter
@@ -183,16 +230,15 @@ adapter.host = 'https://api.example.com';
 Implements OData v4 conventions (PascalCase entity sets, key-in-parentheses URLs, `$filter` / `$expand` / `$select` / `$top` / `$skip` / `$orderby` / `$count`).
 
 ```ts
-import { ODataAdapter } from 'mobx-data/odata';
+import { ODataAdapter } from "@iamjulianacosta/mobx-data/odata";
 
 const adapter = new ODataAdapter();
-adapter.host = 'https://api.example.com/odata';
+adapter.host = "https://api.example.com/odata";
 
-// $expand navigation properties
-const posts = await adapter.query(store, 'post', {
-  $expand: 'author,comments',
+const posts = await adapter.query(store, "post", {
+  $expand: "author,comments",
   $filter: "publishedAt gt '2026-01-01'",
-  $orderby: 'title asc',
+  $orderby: "title asc",
 });
 ```
 
@@ -209,11 +255,11 @@ const posts = await adapter.query(store, 'post', {
 ### EmbeddedRecordsMixin
 
 ```ts
-import { RestSerializer, EmbeddedRecordsMixin } from 'mobx-data/serializer';
+import { RestSerializer, EmbeddedRecordsMixin } from "@iamjulianacosta/mobx-data/serializer";
 
 class PostSerializer extends EmbeddedRecordsMixin(RestSerializer) {
   attrs = {
-    comments: { embedded: 'always' },
+    comments: { embedded: "always" },
   };
 }
 ```
@@ -224,15 +270,15 @@ class PostSerializer extends EmbeddedRecordsMixin(RestSerializer) {
 
 ```ts
 // Sync (records must already be in the store)
-@belongsTo('user', { async: false }) author!: User | null;
-@hasMany('tag',  { async: false })   tags!: ManyArray<Tag>;
+@belongsTo("user", { async: false }) author!: User | null;
+@hasMany("tag", { async: false }) tags!: ManyArray<Tag>;
 
 // Async (loaded on demand)
-@belongsTo('user',    { async: true }) author!: AsyncBelongsTo<User>;
-@hasMany('comment',   { async: true }) comments!: AsyncHasMany<Comment>;
+@belongsTo("user", { async: true }) author!: AsyncBelongsTo<User>;
+@hasMany("comment", { async: true }) comments!: AsyncHasMany<Comment>;
 ```
 
-Async wrappers are `PromiseLike` — they can be `await`ed or used in MobX reactions:
+Async wrappers are `PromiseLike` -- they can be `await`ed or used in MobX reactions:
 
 ```ts
 const author = await post.author; // AsyncBelongsTo<User>
@@ -242,20 +288,58 @@ console.log(post.author.isLoaded); // true
 Inverse tracking is automatic when `inverse` is specified:
 
 ```ts
-@belongsTo('user', { async: false, inverse: 'posts' }) author!: User | null;
+@belongsTo("user", { async: false, inverse: "posts" }) author!: User | null;
 // Setting post.author automatically adds post to user.posts
 ```
 
 ---
 
+## Polymorphic Models
+
+Discriminator-based polymorphism lets you define abstract parent models whose concrete subtype is determined at deserialization time:
+
+```ts
+import { model, attr, Model } from "@iamjulianacosta/mobx-data";
+
+@model({
+  name: "vehicle",
+  abstract: true,
+  discriminator: {
+    key: "vehicleType", // payload field to inspect (defaults to "type")
+    map: {
+      car: () => Car,
+      motorcycle: () => Motorcycle,
+    },
+  },
+})
+abstract class Vehicle extends Model {
+  static modelName = "vehicle";
+  @attr("string") make!: string;
+}
+
+class Car extends Vehicle {
+  static modelName = "car";
+  @attr("number") doors!: number;
+}
+
+class Motorcycle extends Vehicle {
+  static modelName = "motorcycle";
+  @attr("number") cc!: number;
+}
+```
+
+When you push a `vehicle` record, the store reads the discriminator key and instantiates the correct concrete class. All subtypes share the parent's identity map bucket, preventing duplicates.
+
+---
+
 ## Transforms
 
 ```ts
-@attr('string')  name!: string;
-@attr('number')  age!: number;
-@attr('boolean') active!: boolean;
-@attr('date')    createdAt!: Date | null;
-@attr()          raw!: unknown;  // pass-through
+@attr("string") name!: string;
+@attr("number") age!: number;
+@attr("boolean") active!: boolean;
+@attr("date") createdAt!: Date | null;
+@attr() raw!: unknown; // pass-through
 ```
 
 ---
@@ -265,7 +349,7 @@ Inverse tracking is automatic when `inverse` is specified:
 The `RequestManager` provides a middleware-style handler chain:
 
 ```ts
-import { RequestManager, FetchHandler, CacheHandler } from 'mobx-data/request';
+import { RequestManager, FetchHandler, CacheHandler } from "@iamjulianacosta/mobx-data/request";
 
 const manager = new RequestManager()
   .useCache(new CacheHandler())
@@ -304,31 +388,113 @@ Every record exposes observable boolean flags derived from its internal state ma
 | `isValid` | No validation errors |
 
 ```ts
-const post = store.createRecord('post', { title: 'Draft' });
-post.isNew;   // true
+const post = store.createRecord("post", { title: "Draft" });
+post.isNew; // true
 post.isDirty; // true
 
 await post.save();
-post.isNew;   // false
+post.isNew; // false
 post.isDirty; // false
 ```
 
 ---
 
-## Testing
+## MDQL -- Query Builder
 
-The project includes a full end-to-end test suite against an in-process OData server built with [`simple-odata-server`](https://github.com/pofider/simple-odata-server).
+`store.select()` provides a chainable, type-safe query builder for filtering, sorting, and paginating records from the in-memory identity map without going through the adapter:
 
-```bash
-pnpm test          # run all tests once
-pnpm test:watch    # watch mode
-pnpm typecheck     # TypeScript type check
+```ts
+// Published posts, newest first, page 1
+const posts = await store
+  .select<Post>("post")
+  .where("status", "equals", "published")
+  .orderBy("createdAt", "desc")
+  .limit(20)
+  .toArray();
+
+// Boolean logic with nested groups
+const users = await store
+  .select<User>("user")
+  .or((b) => {
+    b.where("name", "equals", "Alice");
+    b.where("name", "startsWith", "B");
+  })
+  .toArray();
+
+// Reactive live query -- updates when the store changes
+const adults = store
+  .select<User>("user")
+  .where("age", "greaterThanOrEquals", 18)
+  .toLiveArray();
+```
+
+Queries compile to structured `MdqlQueryObject` data (not code), making them safe for programmatic construction and AI-generated queries. All queries are validated against the schema before execution.
+
+---
+
+## IndexedDB Cache
+
+Register an `IndexedDBCache` to enable offline-first reads. The store checks the persistent cache before hitting the network, and automatically respects HTTP cache headers (`Cache-Control`, `Expires`):
+
+```ts
+import { IndexedDBCache } from "@iamjulianacosta/mobx-data/cache";
+
+const cache = new IndexedDBCache({
+  databaseName: "my-app-cache", // default: "mobx-data-cache"
+  defaultTTL: 3_600_000, // default: 1 hour
+});
+
+store.registerCache(cache);
+
+// First call: network fetch, result cached in IndexedDB
+const user = await store.findRecord("user", "1");
+
+// Second call (even after page reload): served from IndexedDB instantly
+const user2 = await store.findRecord("user", "1");
 ```
 
-To run the test OData server manually:
+Cache entries are automatically invalidated when records are deleted. The store parses `Cache-Control: max-age`, `s-maxage`, and `Expires` headers to set per-entry TTLs.
+
+---
+
+## Coalesced Find Requests
+
+When `adapter.coalesceFindRequests = true`, multiple concurrent `findRecord` calls for the same model type are batched into a single `findMany` network request:
+
+```ts
+const adapter = new RestAdapter();
+adapter.coalesceFindRequests = true;
+store.registerAdapter("application", adapter);
+
+// These three calls produce a single GET /users?ids[]=1&ids[]=2&ids[]=3
+const [u1, u2, u3] = await Promise.all([
+  store.findRecord("user", "1"),
+  store.findRecord("user", "2"),
+  store.findRecord("user", "3"),
+]);
+```
+
+IDs are deduplicated. Errors propagate to all pending callers. Requests with `include` options bypass coalescing.
+
+---
+
+## Testing
+
+The project uses [Vitest](https://vitest.dev) with 900+ tests covering every subsystem:
+
+- **Unit tests** — model lifecycle, state machine, dirty tracking, snapshots, errors, transforms
+- **Adapter tests** — RestAdapter, JsonApiAdapter, ODataAdapter, MemoryAdapter, buildURL
+- **Serializer tests** — JsonSerializer, RestSerializer, JsonApiSerializer, EmbeddedRecordsMixin
+- **Store tests** — identity map, push, peek, find, query, save, relationships, polymorphism, live queries
+- **MDQL tests** — query builder, validator, memory executor, store integration
+- **Cache tests** — IndexedDB cache, cache utilities, store integration
+- **E2E tests** — full round-trip tests against in-process OData and JSON:API servers
 
 ```bash
-bun tests/e2e/fixtures/run-bun.ts
+npm run test             # run all tests once
+npm run test:watch       # watch mode
+npm run test:coverage    # run with coverage report
+npm run typecheck        # TypeScript type check
 ```
 
 ---
@@ -337,21 +503,26 @@ bun tests/e2e/fixtures/run-bun.ts
 
 ```
 src/
-  adapter/          — Adapter, RestAdapter
-  json-api/         — JsonApiAdapter, JsonApiSerializer
-  model/            — Model, StateMachine, Errors, Snapshot, relationships
-  odata/            — ODataAdapter
-  request/          — RequestManager, FetchHandler, CacheHandler, types
-  schema/           — SchemaService, decorators (@attr, @belongsTo, @hasMany), types
-  serializer/       — Serializer, JsonSerializer, RestSerializer, EmbeddedRecordsMixin
-  store/            — Store, IdentityMap, RecordArray
-  transforms/       — Transform, BooleanTransform, DateTransform, NumberTransform, StringTransform
+  adapter/          -- Adapter, RestAdapter, MemoryAdapter
+  cache/            -- IndexedDBCache, CacheLike interface, cache-utils
+  json-api/         -- JsonApiAdapter, JsonApiSerializer
+  mdql/             -- MdqlQueryBuilder, MdqlValidator, MdqlMemoryExecutor
+  model/            -- Model, StateMachine, Errors, Snapshot, relationships
+  odata/            -- ODataAdapter
+  request/          -- RequestManager, FetchHandler, CacheHandler
+  schema/           -- SchemaService, decorators (@attr, @belongsTo, @hasMany, @model)
+  serializer/       -- Serializer, JsonSerializer, RestSerializer, EmbeddedRecordsMixin
+  store/            -- Store, IdentityMap, RecordArray, createStore
+  transforms/       -- Transform, BooleanTransform, DateTransform, NumberTransform, StringTransform
 tests/
-  e2e/              — end-to-end tests against a live OData server
-    fixtures/       — in-process OData server, seed data, filter engine
-  adapter/          — adapter unit tests
-  model/            — model unit tests
-  (…)
+  adapter/          -- adapter unit tests
+  cache/            -- IndexedDB cache and store integration tests
+  coverage/         -- edge-case tests
+  e2e/              -- end-to-end tests (OData server, JSON:API, cache)
+  mdql/             -- MDQL query builder, validator, executor tests
+  model/            -- model unit tests
+  store/            -- store operation tests
+  (...)
 ```
 
 ---

package/dist/{CacheHandler-BTU_rYkv.js → CacheHandler-BhfbVHed.js}

@@ -1,5 +1,5 @@
 import { injectable as u } from "tsyringe";
-var p = Object.getOwnPropertyDescriptor, f = (e, r, t, s) => {
+var p = Object.getOwnPropertyDescriptor, y = (e, r, t, s) => {
   for (var n = s > 1 ? void 0 : s ? p(r, t) : r, a = e.length - 1, c; a >= 0; a--)
     (c = e[a]) && (n = c(n) || n);
   return n;
@@ -59,17 +59,17 @@ let d = class {
         setResponse(l) {
           this.response = l;
         }
-      }, i = (l) => s(l);
-      return a.request(c, i);
+      }, h = (l) => s(l);
+      return a.request(c, h);
     };
     return s(e);
   }
 };
-d = f([
+d = y([
   u()
 ], d);
-var y = Object.getOwnPropertyDescriptor, _ = (e, r, t, s) => {
-  for (var n = s > 1 ? void 0 : s ? y(r, t) : r, a = e.length - 1, c; a >= 0; a--)
+var f = Object.getOwnPropertyDescriptor, _ = (e, r, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? f(r, t) : r, a = e.length - 1, c; a >= 0; a--)
     (c = e[a]) && (n = c(n) || n);
   return n;
 };
@@ -78,7 +78,7 @@ class v extends Error {
     super(n ?? `Request failed with status ${r}`), this.status = r, this.content = t, this.headers = s;
   }
 }
-let h = class {
+let i = class {
   static headersToObject(e) {
     const r = {};
     return e.forEach((t, s) => {
@@ -113,7 +113,7 @@ let h = class {
       headers: t.headers
     };
     t.body !== void 0 && t.body !== null && (s.body = t.body), t.signal && (s.signal = t.signal);
-    const n = await fetch(t.url, s), a = await h.parseBody(n), c = h.headersToObject(n.headers);
+    const n = await fetch(t.url, s), a = await i.parseBody(n), c = i.headersToObject(n.headers);
     if (!n.ok)
       throw new v(n.status, a, c);
     return {
@@ -124,9 +124,9 @@ let h = class {
     };
   }
 };
-h = _([
+i = _([
   u()
-], h);
+], i);
 var w = Object.getOwnPropertyDescriptor, g = (e, r, t, s) => {
   for (var n = s > 1 ? void 0 : s ? w(r, t) : r, a = e.length - 1, c; a >= 0; a--)
     (c = e[a]) && (n = c(n) || n);
@@ -142,10 +142,7 @@ let o = class {
   evictLRU() {
     for (; this.cache.size > this.maxSize; ) {
       const e = this.cache.keys().next().value;
-      if (e !== void 0)
-        this.cache.delete(e);
-      else
-        break;
+      this.cache.delete(e);
     }
   }
   static keyFor(e) {
@@ -171,12 +168,12 @@ let o = class {
       return r(t);
     const s = o.keyFor(t);
     if (!(((c = t.cacheOptions) == null ? void 0 : c.reload) === !0)) {
-      const i = this.cache.get(s);
-      if (i)
-        if (this.isExpired(i))
+      const h = this.cache.get(s);
+      if (h)
+        if (this.isExpired(h))
           this.cache.delete(s);
         else
-          return this.cache.delete(s), this.cache.set(s, i), i.response;
+          return this.cache.delete(s), this.cache.set(s, h), h.response;
     }
     const a = await r(t);
     return this.cache.set(s, { response: a, cachedAt: Date.now() }), this.evictLRU(), a;
@@ -202,7 +199,7 @@ o = g([
 ], o);
 export {
   o as C,
-  h as F,
+  i as F,
   d as R
 };
-//# sourceMappingURL=CacheHandler-BTU_rYkv.js.map
+//# sourceMappingURL=CacheHandler-BhfbVHed.js.map