@reactive-cache/map 0.3.0 → 1.0.0

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -1,28 +1,334 @@
-# Reactive Cache
+# @reactive-cache/map
 
-<a href="https://www.npmjs.com/package/@reactive-cache/core?activeTab=readme">
+<a href="https://www.npmjs.com/package/@reactive-cache/map">
     <img src="https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white" />
 </a>
 
+A TypeScript library providing reactive, cached map data structures for Angular and RxJS-based projects. Part of the `@reactive-cache` ecosystem.
+
 ## Installation
 
 ```bash
-$ npm install @reactive-cache/map
+npm install @reactive-cache/map
+```
+
+## Features
+
+- **Reactive Caching**: Automatically caches values as RxJS Observables
+- **Lazy Loading**: Values are only fetched when first requested
+- **Multiple Map Types**: Choose between regular maps and weak maps
+- **Mutable & Immutable Options**: Select constant (immutable) or mutable cache behavior
+- **Flexible Input**: Accepts Observables, Promises, or raw values as factory functions
+- **TypeScript Support**: Full type safety with generics
+- **Memory Efficient**: WeakMap variants allow automatic garbage collection
+
+## Map Types
+
+| Class | Key Type | Mutable | Use Case |
+|-------|----------|---------|----------|
+| `ReactiveMap` | `string \| number \| symbol` | Yes | General-purpose cached data with primitive keys |
+| `WeakReactiveMap` | `object` | Yes | Object-keyed data with automatic memory cleanup |
+| `ConstantReactiveMap` | `string \| number \| symbol` | No | Read-only cached data with primitive keys |
+| `ConstantWeakReactiveMap` | `object` | No | Read-only object-keyed data with memory cleanup |
+
+## API Reference
+
+### ReactiveMap<K, V>
+
+A reactive map with primitive keys that supports mutable operations.
+
+```typescript
+import { ReactiveMap } from '@reactive-cache/map';
+
+const map = new ReactiveMap<string, User>(
+  'usersMap',                              // name for debugging
+  (key) => fetchUser(key)                  // factory function
+);
+```
+
+#### Constructor
+
+```typescript
+new ReactiveMap<K, V>(
+  name: string,
+  machine: (key: K) => Observable<V> | Promise<V> | V,
+  params?: { constant?: boolean }
+)
+```
+
+#### Methods
+
+| Method | Return Type | Description |
+|--------|-------------|-------------|
+| `get(key: K)` | `Observable<V>` | Get or create a cached observable for the key |
+| `next(key: K, value: V)` | `void` | Emit a new value for the key |
+| `reset(key: K)` | `void` | Reset the cache state for the key |
+| `update(key: K)` | `Observable<V>` | Force refresh the cached value |
+| `delete(key: K)` | `void` | Remove the key from the map |
+| `has(key: K)` | `boolean` | Check if the key exists |
+| `clear()` | `void` | Remove all entries |
+
+### WeakReactiveMap<K, V>
+
+Same API as `ReactiveMap` but uses `WeakMap` internally. Keys must be objects.
+
+```typescript
+import { WeakReactiveMap } from '@reactive-cache/map';
+
+const map = new WeakReactiveMap<UserRef, UserData>(
+  'weakUsersMap',
+  (userRef) => fetchUserData(userRef.id)
+);
+```
+
+### ConstantReactiveMap<K, V>
+
+An immutable reactive map with primitive keys. Does not support `next`, `reset`, or `update` methods.
+
+```typescript
+import { ConstantReactiveMap } from '@reactive-cache/map';
+
+const map = new ConstantReactiveMap<string, Config>(
+  'configMap',
+  (key) => loadConfig(key)
+);
+```
+
+#### Methods
+
+| Method | Return Type | Description |
+|--------|-------------|-------------|
+| `get(key: K)` | `Observable<V>` | Get or create a cached observable for the key |
+| `delete(key: K)` | `void` | Remove the key from the map |
+| `clear()` | `void` | Remove all entries |
+
+### ConstantWeakReactiveMap<K, V>
+
+Same API as `ConstantReactiveMap` but uses `WeakMap` internally. Keys must be objects.
+
+```typescript
+import { ConstantWeakReactiveMap } from '@reactive-cache/map';
+
+const map = new ConstantWeakReactiveMap<Document, Metadata>(
+  'docMetaMap',
+  (doc) => extractMetadata(doc)
+);
+```
+
+## Usage Examples
+
+### Basic Usage with Synchronous Values
+
+```typescript
+import { ReactiveMap } from '@reactive-cache/map';
+
+const greetingMap = new ReactiveMap<string, string>(
+  'greetings',
+  (name) => `Hello, ${name}!`
+);
+
+greetingMap.get('World').subscribe(console.log);
+// Output: Hello, World!
+
+// Update the value
+greetingMap.next('World', 'Hi, World!');
+greetingMap.get('World').subscribe(console.log);
+// Output: Hi, World!
+```
+
+### Async Data Fetching
+
+```typescript
+import { ReactiveMap } from '@reactive-cache/map';
+import { Observable } from 'rxjs';
+
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+const usersMap = new ReactiveMap<number, User | null>(
+  'users',
+  (userId) => ajax(`/api/users/${userId}`).pipe(
+    catchError((err) => null);
+  )
+);
+
+// First call fetches from API
+usersMap.get(1).subscribe(user => {
+  console.log(user.name);
+});
+
+// Second call returns cached value
+usersMap.get(1).subscribe(user => {
+  console.log(user.name); // No API call, uses cache
+});
+
+// Force refresh
+usersMap.update(1).subscribe(user => {
+  console.log('Refreshed:', user.name);
+});
+```
+
+### Using with Promises
+
+```typescript
+import { ReactiveMap } from '@reactive-cache/map';
+
+const dataMap = new ReactiveMap<string, any>(
+  'apiData',
+  (endpoint) => fetch(`/api/${endpoint}`).then(res => res.json())
+);
+
+dataMap.get('posts').subscribe(posts => {
+  console.log('Posts:', posts);
+});
 ```
 
+### Angular Service Example
+
+```typescript
+import { Injectable } from '@angular/core';
+import { ReactiveMap } from '@reactive-cache/map';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+interface Product {
+  id: number;
+  name: string;
+  price: number;
+}
+
+@Injectable({ providedIn: 'root' })
+export class ProductService {
+  private productsMap = new ReactiveMap<number, Product>(
+    'products',
+    (id) => this.http.get<Product>(`/api/products/${id}`)
+  );
+
+  constructor(private http: HttpClient) {}
+
+  getProduct(id: number): Observable<Product> {
+    return this.productsMap.get(id);
+  }
+
+  refreshProduct(id: number): Observable<Product> {
+    return this.productsMap.update(id);
+  }
+
+  updateProductLocally(id: number, product: Product): void {
+    this.productsMap.next(id, product);
+  }
+
+  clearCache(): void {
+    this.productsMap.clear();
+  }
+}
+```
+
+### Using WeakReactiveMap for Object Keys
+
+```typescript
+import { WeakReactiveMap } from '@reactive-cache/map';
+
+interface Component {
+  id: string;
+  type: string;
+}
+
+interface ComponentState {
+  isLoaded: boolean;
+  data: any;
+}
+
+const componentStates = new WeakReactiveMap<Component, ComponentState>(
+  'componentStates',
+  (component) => ({
+    isLoaded: false,
+    data: null
+  })
+);
 
-## Usage
+const myComponent = { id: '1', type: 'widget' };
+
+componentStates.get(myComponent).subscribe(state => {
+  console.log('State:', state);
+});
+
+// Update state
+componentStates.next(myComponent, {
+  isLoaded: true,
+  data: { content: 'Hello' }
+});
+
+// When myComponent is garbage collected, the cache entry is automatically removed
+```
+
+### Immutable Configuration Cache
 
 ```typescript
-import { ReactiveMap } from 'reactive-cache/map';
+import { ConstantReactiveMap } from '@reactive-cache/map';
 
-const map = new ReactiveMap<string, object>('map', (key: string) => {
-    return fetch('http://...' + key)
+interface FeatureConfig {
+  enabled: boolean;
+  settings: Record<string, any>;
+}
+
+const configMap = new ConstantReactiveMap<string, FeatureConfig>(
+  'featureConfigs',
+  (featureName) => fetch(`/api/config/${featureName}`).then(r => r.json())
+);
+
+// Values cannot be modified after initial fetch
+configMap.get('darkMode').subscribe(config => {
+  console.log('Dark mode enabled:', config.enabled);
 });
 
-map.get('1').subscribe(console.log);
-// data is fetched only once
-setTimeout(() => {
-    map.get('1').subscribe()
-}, 5000)
-```
+// configMap.next() - Not available on ConstantReactiveMap
+// configMap.reset() - Not available on ConstantReactiveMap
+```
+
+## Type Definitions
+
+```typescript
+// Input type for factory functions
+type ArgType<T> = Observable<T> | Promise<T> | T;
+
+// Key types
+type PrimitiveKey = string | number | symbol;
+type ObjectKey = object;
+```
+
+## When to Use Each Map Type
+
+| Scenario | Recommended Type |
+|----------|------------------|
+| API responses that may need updating | `ReactiveMap` |
+| Static configuration data | `ConstantReactiveMap` |
+| Component instances as keys | `WeakReactiveMap` |
+| DOM elements as keys (read-only) | `ConstantWeakReactiveMap` |
+| User session data | `ReactiveMap` |
+| Translated strings | `ConstantReactiveMap` |
+| Temporary object associations | `WeakReactiveMap` |
+
+## Dependencies
+
+- [rxjs](https://rxjs.dev/) ^7.8.1
+- [@reactive-cache/core](https://www.npmjs.com/package/@reactive-cache/core) ^3.2.0
+
+## Related Packages
+
+- [@reactive-cache/core](https://www.npmjs.com/package/@reactive-cache/core) - Core reactive caching functionality
+
+## License
+
+ISC
+
+## Author
+
+[Jor-ban](https://github.com/Jor-ban)
+
+## Repository
+
+[https://github.com/Jor-ban/reactive-cache](https://github.com/Jor-ban/reactive-cache)

package/package.json

@@ -1,39 +1,39 @@
-{
-  "name": "@reactive-cache/map",
-  "version": "0.3.0",
-  "type": "module",
-  "scripts": {
-    "test": "npx tsc && tsx watch src/test.ts && echo 'all tests are complete!'",
-    "prepare": "npx tsc && rm -f ./dist/test.js"
-  },
-  "devDependencies": {
-    "axios": "^1.7.9",
-    "ts-node": "^10.9.2",
-    "tsx": "^4.19.2",
-    "typescript": "^5.5.3"
-  },
-  "dependencies": {
-    "rxjs": "^7.8.1",
-    "@reactive-cache/core": "^2.6.0"
-  },
-  "description": "reactive map for angular and rxjs projects",
-  "main": "dist/index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Jor-ban/reactive-cache.git"
-  },
-  "keywords": [
-    "angular",
-    "rxjs",
-    "signal",
-    "cache",
-    "state-manager",
-    "state"
-  ],
-  "author": "https://github.com/Jor-ban",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/Jor-ban/reactive-cache/issues"
-  },
-  "homepage": "https://github.com/Jor-ban/reactive-cache#readme"
-}
+{
+  "name": "@reactive-cache/map",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "test": "npx tsc && tsx watch src/test.ts && echo 'all tests are complete!'",
+    "prepare": "npx tsc && rm -f ./dist/test.js"
+  },
+  "devDependencies": {
+    "axios": "^1.7.9",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "rxjs": "^7.8.1",
+    "@reactive-cache/core": "^3.2.0"
+  },
+  "description": "reactive map for angular and rxjs projects",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jor-ban/reactive-cache.git"
+  },
+  "keywords": [
+    "angular",
+    "rxjs",
+    "signal",
+    "cache",
+    "state-manager",
+    "state"
+  ],
+  "author": "https://github.com/Jor-ban",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/Jor-ban/reactive-cache/issues"
+  },
+  "homepage": "https://github.com/Jor-ban/reactive-cache#readme"
+}

package/src/index.ts

@@ -1,203 +1,203 @@
-import {
-  __createReactiveCache__,
-  ConstantReactiveCacheObservable,
-  ReactiveCacheObservable,
-  __REACTIVE_CACHE_WINDOW_PROP_NAME__,
-  ReactiveCacheObservableParameters
-} from "@reactive-cache/core"
-import {Observable, Subject} from "rxjs";
-
-export type ArgType<T> = Observable<T> | Promise<T> | T
-export type __ReactiveMapType__ = ReactiveMap<any, any> | WeakReactiveMap<any, any> | ConstantReactiveMap<any, any> | ConstantWeakReactiveMap<any, any>
-
-const __REACTIVE_MAPS_LIST__: __ReactiveMapType__[] = []
-const __REACTIVE_MAPS_ON_UPDATE_MAP__: WeakMap<__ReactiveMapType__, Observable<any>> = new WeakMap()
-const __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__: Subject<void> = new Subject<void>()
-
-try {
-  const WINDOW = this || global || window
-  if(WINDOW && typeof WINDOW === 'object') {
-    // @ts-ignore
-    window.addEventListener('load', () => {
-      // @ts-ignore
-      if(!WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__) {
-        // @ts-ignore
-        WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__ = {}
-      }
-      // @ts-ignore
-      WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__['__REACTIVE_MAPS_LIST__'] = __REACTIVE_MAPS_LIST__
-      // @ts-ignore
-      WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__['__REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__'] = __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__
-      // @ts-ignore
-      WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__['__REACTIVE_MAPS_ON_UPDATE_MAP__'] = __REACTIVE_MAPS_ON_UPDATE_MAP__
-    })
-  }
-} catch(_ignored) {}
-
-export class ReactiveMap<K extends string | number | symbol, V> {
-  private readonly map = new Map<K, ReactiveCacheObservable<V>>()
-  private readonly onUpdateSubject = new Subject<V | Symbol>()
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>, params?: { constant?: boolean }) {
-    __REACTIVE_MAPS_LIST__.push(this)
-    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
-    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
-  }
-
-  public get(key: K): Observable<V> {
-    const value = this.map.get(key)
-    if (value) {
-      return value
-    }
-    const { rc } = __createReactiveCache__(this.machine(key), {}, (v) => {
-      this.onUpdateSubject.next(v)
-    })
-    this.map.set(key, rc as ReactiveCacheObservable<V>)
-    return rc
-  }
-
-  public next(key: K, value: V): void {
-    const subject = this.map.get(key)
-    if (subject) {
-      subject.next(value)
-    }
-  }
-
-  public reset(key: K): void {
-    const subject = this.map.get(key)
-    if (subject) {
-      subject.resetState()
-    }
-  }
-
-  public delete(key: K): void {
-    this.map.delete(key)
-  }
-
-  public update(key: K): Observable<V> {
-    const subject = this.map.get(key)
-    if (subject) {
-      return subject.update()
-    }
-    return this.get(key)
-  }
-
-  public has(key: K): boolean {
-    return this.map.has(key)
-  }
-
-  public clear(): void {
-    this.map.clear()
-  }
-}
-
-export class WeakReactiveMap<K extends object, V> {
-  private readonly map = new WeakMap<K, ReactiveCacheObservable<V>>()
-  private readonly onUpdateSubject = new Subject<V | Symbol>()
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>, params?: { constant?: boolean }) {
-    __REACTIVE_MAPS_LIST__.push(this)
-    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
-    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
-  }
-
-  public get(key: K): Observable<V> {
-    const value = this.map.get(key)
-    if (value) {
-      return value
-    }
-    const { rc } = __createReactiveCache__(this.machine(key), {}, (v) => {
-      this.onUpdateSubject.next(v)
-    })
-    this.map.set(key, rc as ReactiveCacheObservable<V>)
-    return rc
-  }
-
-  public next(key: K, value: V): void {
-    const subject = this.map.get(key)
-    if (subject) {
-      subject.next(value)
-    }
-  }
-
-  public reset(key: K): void {
-    const subject = this.map.get(key)
-    if (subject) {
-      subject.resetState()
-    }
-  }
-
-  public delete(key: K): void {
-    this.map.delete(key)
-  }
-
-  public update(key: K): Observable<V> {
-    const subject = this.map.get(key)
-    if (subject) {
-      return subject.update()
-    }
-    return this.get(key)
-  }
-
-  public has(key: K): boolean {
-    return this.map.has(key)
-  }
-}
-
-export class ConstantReactiveMap<K extends string | number | symbol, V> {
-  private readonly map = new Map<K, ConstantReactiveCacheObservable<V>>()
-  private readonly onUpdateSubject = new Subject<V | Symbol>()
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>) {
-    __REACTIVE_MAPS_LIST__.push(this)
-    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
-    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
-  }
-
-  public get(key: K): Observable<V> {
-    const value = this.map.get(key)
-    if (value) {
-      return value
-    }
-    const { rc } = __createReactiveCache__(this.machine(key), { constant: true }, (v) => {
-      this.onUpdateSubject.next(v)
-    })
-    this.map.set(key, rc as ConstantReactiveCacheObservable<V>)
-    return rc
-  }
-
-  public delete(key: K): void {
-    this.map.delete(key)
-  }
-
-  public clear(): void {
-    this.map.clear()
-  }
-}
-
-export class ConstantWeakReactiveMap<K extends object, V> {
-  private readonly map = new Map<K, ConstantReactiveCacheObservable<V>>()
-  private readonly onUpdateSubject = new Subject<V | Symbol>()
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>) {
-    __REACTIVE_MAPS_LIST__.push(this)
-    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
-    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
-  }
-
-  public get(key: K): Observable<V> {
-    const value = this.map.get(key)
-    if (value) {
-      return value
-    }
-    const { rc } = __createReactiveCache__(this.machine(key), { constant: true }, (v) => {
-      this.onUpdateSubject.next(v)
-    })
-    this.map.set(key, rc as ConstantReactiveCacheObservable<V>)
-    return rc
-  }
-
-  public delete(key: K): void {
-    this.map.delete(key)
-  }
-
-  public clear(): void {
-    this.map.clear()
-  }
+import {
+  __createReactiveCache__,
+  ConstantReactiveCacheObservable,
+  ReactiveCacheObservable,
+  __REACTIVE_CACHE_WINDOW_PROP_NAME__,
+  ReactiveCacheObservableParameters
+} from "@reactive-cache/core"
+import {Observable, Subject} from "rxjs";
+
+export type ArgType<T> = Observable<T> | Promise<T> | T
+export type __ReactiveMapType__ = ReactiveMap<any, any> | WeakReactiveMap<any, any> | ConstantReactiveMap<any, any> | ConstantWeakReactiveMap<any, any>
+
+const __REACTIVE_MAPS_LIST__: __ReactiveMapType__[] = []
+const __REACTIVE_MAPS_ON_UPDATE_MAP__: WeakMap<__ReactiveMapType__, Observable<any>> = new WeakMap()
+const __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__: Subject<void> = new Subject<void>()
+
+try {
+  const WINDOW = this || global || window
+  if(WINDOW && typeof WINDOW === 'object') {
+    // @ts-ignore
+    window.addEventListener('load', () => {
+      // @ts-ignore
+      if(!WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__) {
+        // @ts-ignore
+        WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__ = {}
+      }
+      // @ts-ignore
+      WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__['__REACTIVE_MAPS_LIST__'] = __REACTIVE_MAPS_LIST__
+      // @ts-ignore
+      WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__['__REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__'] = __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__
+      // @ts-ignore
+      WINDOW.__REACTIVE_CACHE_WINDOW_PROP_NAME__['__REACTIVE_MAPS_ON_UPDATE_MAP__'] = __REACTIVE_MAPS_ON_UPDATE_MAP__
+    })
+  }
+} catch(_ignored) {}
+
+export class ReactiveMap<K extends string | number | symbol, V> {
+  private readonly map = new Map<K, ReactiveCacheObservable<V>>()
+  private readonly onUpdateSubject = new Subject<V | Symbol>()
+  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>, params?: { constant?: boolean }) {
+    __REACTIVE_MAPS_LIST__.push(this)
+    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
+    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
+  }
+
+  public get(key: K): Observable<V> {
+    const value = this.map.get(key)
+    if (value) {
+      return value
+    }
+    const { rc } = __createReactiveCache__(this.machine(key), {}, (v) => {
+      this.onUpdateSubject.next(v)
+    })
+    this.map.set(key, rc as ReactiveCacheObservable<V>)
+    return rc
+  }
+
+  public next(key: K, value: V): void {
+    const subject = this.map.get(key)
+    if (subject) {
+      subject.next(value)
+    }
+  }
+
+  public reset(key: K): void {
+    const subject = this.map.get(key)
+    if (subject) {
+      subject.resetState()
+    }
+  }
+
+  public delete(key: K): void {
+    this.map.delete(key)
+  }
+
+  public update(key: K): Observable<V> {
+    const subject = this.map.get(key)
+    if (subject) {
+      return subject.update()
+    }
+    return this.get(key)
+  }
+
+  public has(key: K): boolean {
+    return this.map.has(key)
+  }
+
+  public clear(): void {
+    this.map.clear()
+  }
+}
+
+export class WeakReactiveMap<K extends object, V> {
+  private readonly map = new WeakMap<K, ReactiveCacheObservable<V>>()
+  private readonly onUpdateSubject = new Subject<V | Symbol>()
+  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>, params?: { constant?: boolean }) {
+    __REACTIVE_MAPS_LIST__.push(this)
+    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
+    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
+  }
+
+  public get(key: K): Observable<V> {
+    const value = this.map.get(key)
+    if (value) {
+      return value
+    }
+    const { rc } = __createReactiveCache__(this.machine(key), {}, (v) => {
+      this.onUpdateSubject.next(v)
+    })
+    this.map.set(key, rc as ReactiveCacheObservable<V>)
+    return rc
+  }
+
+  public next(key: K, value: V): void {
+    const subject = this.map.get(key)
+    if (subject) {
+      subject.next(value)
+    }
+  }
+
+  public reset(key: K): void {
+    const subject = this.map.get(key)
+    if (subject) {
+      subject.resetState()
+    }
+  }
+
+  public delete(key: K): void {
+    this.map.delete(key)
+  }
+
+  public update(key: K): Observable<V> {
+    const subject = this.map.get(key)
+    if (subject) {
+      return subject.update()
+    }
+    return this.get(key)
+  }
+
+  public has(key: K): boolean {
+    return this.map.has(key)
+  }
+}
+
+export class ConstantReactiveMap<K extends string | number | symbol, V> {
+  private readonly map = new Map<K, ConstantReactiveCacheObservable<V>>()
+  private readonly onUpdateSubject = new Subject<V | Symbol>()
+  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>) {
+    __REACTIVE_MAPS_LIST__.push(this)
+    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
+    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
+  }
+
+  public get(key: K): Observable<V> {
+    const value = this.map.get(key)
+    if (value) {
+      return value
+    }
+    const { rc } = __createReactiveCache__(this.machine(key), { constant: true }, (v) => {
+      this.onUpdateSubject.next(v)
+    })
+    this.map.set(key, rc as ConstantReactiveCacheObservable<V>)
+    return rc
+  }
+
+  public delete(key: K): void {
+    this.map.delete(key)
+  }
+
+  public clear(): void {
+    this.map.clear()
+  }
+}
+
+export class ConstantWeakReactiveMap<K extends object, V> {
+  private readonly map = new Map<K, ConstantReactiveCacheObservable<V>>()
+  private readonly onUpdateSubject = new Subject<V | Symbol>()
+  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>) {
+    __REACTIVE_MAPS_LIST__.push(this)
+    __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__.next()
+    __REACTIVE_MAPS_ON_UPDATE_MAP__.set(this, this.onUpdateSubject)
+  }
+
+  public get(key: K): Observable<V> {
+    const value = this.map.get(key)
+    if (value) {
+      return value
+    }
+    const { rc } = __createReactiveCache__(this.machine(key), { constant: true }, (v) => {
+      this.onUpdateSubject.next(v)
+    })
+    this.map.set(key, rc as ConstantReactiveCacheObservable<V>)
+    return rc
+  }
+
+  public delete(key: K): void {
+    this.map.delete(key)
+  }
+
+  public clear(): void {
+    this.map.clear()
+  }
 }

package/.idea/material_theme_project_new.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="MaterialThemeProjectNewConfig">
-    <option name="metadata">
-      <MTProjectMetadataState>
-        <option name="migrated" value="true" />
-        <option name="pristineConfig" value="false" />
-        <option name="userId" value="-4b6355e5:18c908035a5:-8000" />
-        <option name="version" value="8.13.2" />
-      </MTProjectMetadataState>
-    </option>
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/reactive-map.iml" filepath="$PROJECT_DIR$/.idea/reactive-map.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/reactive-map.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

package/dist/index.d.ts

@@ -1,44 +0,0 @@
-import {Observable, Subject} from "rxjs";
-import {__createReactiveCache__, ConstantReactiveCacheObservable} from "@reactive-cache/core";
-
-export type ArgType<T> = Observable<T> | Promise<T> | T
-export type __ReactiveMapType__ = ReactiveMap<any, any> | WeakReactiveMap<any, any> | ConstantReactiveMap<any, any>
-
-const __REACTIVE_MAPS_LIST__: __ReactiveMapType__[] = []
-const __REACTIVE_MAPS_ON_UPDATE_MAP__: WeakMap<__ReactiveMapType__, Observable<any>> = new WeakMap()
-const __REACTIVE_MAPS_LIST_UPDATE_OBSERVABLE__: Subject<void> = new Subject<void>()
-
-export class ReactiveMap<K extends string | number | symbol, V> {
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>)
-  public get(key: K): Observable<V>
-  public next(key: K, value: V): void
-  public reset(key: K): void
-  public delete(key: K): void
-  public update(key: K): Observable<V>
-  public has(key: K): boolean
-  public clear(): void
-}
-
-export class WeakReactiveMap<K extends object, V> {
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>)
-  public get(key: K): Observable<V>
-  public next(key: K, value: V): void
-  public reset(key: K): void
-  public delete(key: K): void
-  public update(key: K): Observable<V>
-  public has(key: K): boolean
-}
-
-export class ConstantReactiveMap<K extends string | number | symbol, V> {
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>)
-  public get(key: K): Observable<V>
-  public delete(key: K): void
-  public clear(): void
-}
-
-export class ConstantWeakReactiveMap<K extends object, V> {
-  public constructor(public readonly name: string, private readonly machine: (value: K) => ArgType<V>)
-  public get(key: K): Observable<V>
-  public delete(key: K): void
-  public clear(): void
-}