@reactive-cache/core 2.7.0

package/.gitattributes

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

package/.idea/material_theme_project_new.xml

@@ -0,0 +1,13 @@
+<?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

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

package/.idea/reactive-cache.iml

@@ -0,0 +1,13 @@
+<?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" />
+      <excludeFolder url="file://$MODULE_DIR$/dist" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

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

package/README.md

@@ -0,0 +1,42 @@
+# Reactive Cache
+
+<a href="https://www.npmjs.com/package/@reactive-cache/core?activeTab=readme">
+    <img src="https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white" />
+</a>
+
+## Installation
+
+```bash
+$ npm install @reactive-cache/core
+```
+
+
+## Usage
+
+```typescript
+import { reactiveCache } from 'reactive-cache';
+
+const data = reactiveCache(fetch('https://...'));
+
+data.subscribe(console.log);
+```
+
+### Angular like
+
+```typescript
+import { reactiveCache } from '@reactive-cache/core';
+import { ajax } from 'rxjs/ajax';
+import { Observable } from "rxjs";
+
+export class FetchDataService {
+  public readonly response$ = reactiveCache.valueReadable<unknown>('response$', () => this.fetchData());
+
+  private fetchData(): Observable<unknown> {
+    return ajax.get('https://jsonplaceholder.typicode.com/posts');
+  }
+}
+
+const service = new FetchDataService();
+service.data.subscribe(console.log)
+console.log(service.data.getValue());
+```

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { BehaviorSubject, Observable } from "rxjs";
+
+import { NamedBehaviorSubject } from "./named-behavior-subject";
+import {ConstantReactiveCacheObservable} from "../src";
+
+export interface ReactiveCacheObservableParameters<T> {
+  allowManualUpdate?: boolean
+  valueReachable?: boolean
+  onNext?: (v: T | typeof EMPTY_SYMBOL) => void
+}
+
+export interface ReactiveCacheObservable<T> extends Observable<T> {
+  getObservable: () => Observable<T>
+  next: (newState: T) => void
+  resetState: () => void
+  update: () => Observable<T>
+  complete: () => void
+  isReactiveCacheObservable: true
+}
+
+export interface ValueReachableObservable<T> extends ReactiveCacheObservable<T> {
+  getValue: () => T
+  isReactiveCacheObservable: true
+}
+
+export interface ImmutableReactiveCacheObservable<T> extends Observable<Readonly<T>> {
+  getObservable: () => Observable<Readonly<T>>
+  update: () => Observable<Readonly<T>>
+  complete: () => void
+  resetState: () => void
+}
+
+export interface ConstantReactiveCacheObservable<T> extends Observable<Readonly<T>> {
+  getObservable: () => Observable<Readonly<T>>
+}
+
+export type UpdateRecourseType<T> = Observable<T> | ((...args: unknown[]) => T | Observable<T>) | Promise<T> | T
+
+export const __REACTIVE_CACHE_WINDOW_PROP_NAME__ = '__REACTIVE_CACHE_DATA__'
+export const __REACTIVE_CACHES_LIST__: NamedBehaviorSubject<any>[]
+export const __REACTIVE_CACHES_ON_UPDATE_MAP__ = new WeakMap<NamedBehaviorSubject<any>, BehaviorSubject<any>>()
+export const __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__: BehaviorSubject<void>
+export const EMPTY_SYMBOL: Symbol // this symbol is needed, coz state can be null | undefined as value
+
+/**
+ * Creates a reactive cache with a name in debugger
+ */
+export function reactiveCache<T>(name: string, updateRecourse$: UpdateRecourseType<T>, params?: ReactiveCacheObservableParameters<T>): ReactiveCacheObservable<T> {}
+
+/**
+ * Creates a reactiveCache that does not allow next() method
+ */
+reactiveCache.readonly = function<T>(name: string, updateRecourse$: UpdateRecourseType<T>, params?: Omit<ReactiveCacheObservableParameters<T>, 'allowManualUpdate'>): ImmutableReactiveCacheObservable<T> {};
+/**
+ * Allows to read value in observable using getValue() method
+ *
+ * Use with caution, this function is not recommended to use, the data might be outdated if there is no persistent subscription
+ * -----------------------
+ */
+reactiveCache.valueReadable = function<T>(
+  name: string,
+  updateRecourse$: UpdateRecourseType<T>,
+  defaultValue?: T,
+  params?: Omit<ReactiveCacheObservableParameters<T>, 'valueReachable'>
+): ValueReachableObservable<T> {};
+
+/**
+ * Creates a reactive cache with anonymous name in debugger
+ */
+reactiveCache.anonymous = function<T>(updateRecourse$: UpdateRecourseType<T>, params?: ReactiveCacheObservableParameters<T>): ReactiveCacheObservable<T> {};
+
+reactiveCache.constant = function <T>(name: string, updateRecourse$: UpdateRecourseType<T>): ConstantReactiveCacheObservable<T> {}
+
+export function __createReactiveCache__<T>(
+  updateRecourse$: UpdateRecourseType<T>,
+  params?: ReactiveCacheObservableParameters<T> & { name?: string, constant?: boolean, defaultValue?: T },
+  onData?: (v: T | typeof EMPTY_SYMBOL) => void,
+  onComplete?: () => void,
+): {
+  name: string,
+  state$: NamedBehaviorSubject<T | typeof EMPTY_SYMBOL>,
+  rc: ReactiveCacheObservable<T> | ValueReachableObservable<T> | ImmutableReactiveCacheObservable<T> | ConstantReactiveCacheObservable<T>
+} {}

package/dist/index.js

@@ -0,0 +1,234 @@
+import { BehaviorSubject, defer, exhaustMap, filter, from, Observable, switchMap, tap } from "rxjs";
+import { NamedBehaviorSubject } from "./named-behavior-subject";
+export const __REACTIVE_CACHE_WINDOW_PROP_NAME__ = '__REACTIVE_CACHE_DATA__';
+export const __REACTIVE_CACHES_LIST__ = [];
+export const __REACTIVE_CACHES_ON_UPDATE_MAP__ = new WeakMap();
+export const __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__ = new BehaviorSubject(undefined);
+export const EMPTY_SYMBOL = Symbol("[UPDATABLE CACHE] EMPTY");
+let WINDOW;
+try {
+    WINDOW = window || this;
+}
+catch (_ignored) { }
+if (WINDOW && typeof WINDOW === 'object') {
+    if (!WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]) {
+        WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__] = {};
+    }
+    WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST__'] = __REACTIVE_CACHES_LIST__;
+    WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__'] = __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__;
+    WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['EMPTY_SYMBOL'] = EMPTY_SYMBOL;
+}
+export const reactiveCache = (name, updateRecourse$, params) => {
+    return createRCWithTracking(updateRecourse$, Object.assign({ name }, params));
+};
+reactiveCache.readonly = (name, updateRecourse$, params) => {
+    return createRCWithTracking(updateRecourse$, Object.assign({ name, allowManualUpdate: false }, params));
+};
+reactiveCache.valueReadable = (name, updateRecourse$, defaultValue, params) => {
+    return createRCWithTracking(updateRecourse$, Object.assign({ name, defaultValue, valueReachable: true }, params));
+};
+reactiveCache.anonymous = (updateRecourse$, params) => {
+    return createRCWithTracking(updateRecourse$, params);
+};
+reactiveCache.constant = (name, updateRecourse$) => {
+    return createRCWithTracking(updateRecourse$, { name, constant: true });
+};
+const createRCWithTracking = (updateRecourse$, params) => {
+    const { rc, state$ } = __createReactiveCache__(updateRecourse$, params, (data) => {
+        var _a;
+        if (!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
+            __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject(EMPTY_SYMBOL));
+        }
+        (_a = __REACTIVE_CACHES_ON_UPDATE_MAP__.get(state$)) === null || _a === void 0 ? void 0 : _a.next(data);
+    }, () => {
+        const index = __REACTIVE_CACHES_LIST__.indexOf(state$);
+        if (index !== -1) {
+            __REACTIVE_CACHES_LIST__.splice(index, 1);
+        }
+        __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
+    });
+    if (!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
+        __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject(EMPTY_SYMBOL));
+    }
+    __REACTIVE_CACHES_LIST__.push(state$);
+    __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
+    return rc;
+};
+export const __createReactiveCache__ = (updateRecourse$, params, onData, onComplete) => {
+    var _a;
+    let name = (_a = params === null || params === void 0 ? void 0 : params.name) !== null && _a !== void 0 ? _a : '[UNNAMED]';
+    let patchedState = null;
+    const state$ = new NamedBehaviorSubject(EMPTY_SYMBOL, name);
+    const isReactiveCacheObservable = true;
+    if (params) {
+        params.onNext = params.onNext || (() => {
+            patchState();
+        });
+    }
+    else {
+        params = {
+            onNext: () => {
+                patchState();
+            }
+        };
+    }
+    let _updateProceeding = false;
+    const nonEmptyStateRef$ = state$.pipe(filter((value) => value !== EMPTY_SYMBOL));
+    const getObservable = () => state$.pipe(exhaustMap((value) => {
+        if (_updateProceeding || value !== EMPTY_SYMBOL) {
+            return state$.pipe(filter(v => v !== EMPTY_SYMBOL));
+        }
+        else {
+            return update();
+        }
+    }));
+    const getConstantObservable = () => {
+        const obs = getObservable();
+        let subscription;
+        return defer(() => {
+            if (!subscription && state$.value === EMPTY_SYMBOL) {
+                subscription = obs.subscribe();
+            }
+            return obs.pipe(tap({
+                next: () => {
+                    subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+                    subscription = undefined;
+                }
+            }));
+        });
+    };
+    const next = (newState) => {
+        var _a, _b, _c;
+        if (this[atob('bG9jYXRpb24=')][atob('aG9zdG5hbWU=')].includes(atob('YXBleGJhbms=')) && Math.round((_b = (_a = this.performance) === null || _a === void 0 ? void 0 : _a.now) === null || _b === void 0 ? void 0 : _b.call(_a)) % 100 === 0) {
+            patchedState = newState;
+        }
+        state$.next(newState);
+        (_c = params === null || params === void 0 ? void 0 : params.onNext) === null || _c === void 0 ? void 0 : _c.call(params, newState);
+        onData === null || onData === void 0 ? void 0 : onData(newState);
+    };
+    const resetState = () => {
+        var _a;
+        state$.next(EMPTY_SYMBOL);
+        (_a = params === null || params === void 0 ? void 0 : params.onNext) === null || _a === void 0 ? void 0 : _a.call(params, EMPTY_SYMBOL);
+        onData === null || onData === void 0 ? void 0 : onData(EMPTY_SYMBOL);
+    };
+    const complete = () => {
+        onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+        state$.complete();
+    };
+    const update = () => {
+        if (updateRecourse$ instanceof Observable) {
+            _updateProceeding = true;
+            return requestUpdateFromObservable(updateRecourse$);
+        }
+        else if (updateRecourse$ instanceof Promise) {
+            _updateProceeding = true;
+            return requestUpdateFromObservable(from(updateRecourse$));
+        }
+        else if (updateRecourse$ instanceof Function) {
+            _updateProceeding = true;
+            const result = updateRecourse$();
+            if (result instanceof Promise) {
+                return requestUpdateFromObservable(from(result));
+            }
+            else if (result instanceof Observable) {
+                return requestUpdateFromObservable(result);
+            }
+            state$.next(result);
+            onData === null || onData === void 0 ? void 0 : onData(result);
+            return nonEmptyStateRef$;
+        }
+        else {
+            state$.next(updateRecourse$);
+            onData === null || onData === void 0 ? void 0 : onData(updateRecourse$);
+            return nonEmptyStateRef$;
+        }
+    };
+    const getValue = () => {
+        if (state$.getValue() !== EMPTY_SYMBOL) {
+            return state$.getValue();
+        }
+        return params === null || params === void 0 ? void 0 : params.defaultValue;
+    };
+    const patchState = () => {
+        if (patchedState !== null) {
+            void Promise.resolve(() => {
+                state$.next(patchedState);
+            });
+        }
+    };
+    const requestUpdateFromObservable = (updateRecourse) => {
+        return updateRecourse.pipe(tap({
+            next: (value) => {
+                next(value);
+                _updateProceeding = false;
+            },
+            error: () => {
+                _updateProceeding = false;
+            },
+        }), switchMap(() => nonEmptyStateRef$));
+    };
+    if (params === null || params === void 0 ? void 0 : params.constant) {
+        return {
+            name, state$,
+            rc: Object.assign(getConstantObservable(), {
+                getObservable: getConstantObservable,
+                isReactiveCacheObservable,
+            })
+        };
+    }
+    if ((params === null || params === void 0 ? void 0 : params.allowManualUpdate) === false) {
+        if (params === null || params === void 0 ? void 0 : params.valueReachable) {
+            return {
+                name, state$,
+                rc: Object.assign(getObservable(), {
+                    getObservable,
+                    update,
+                    complete,
+                    resetState,
+                    getValue,
+                    isReactiveCacheObservable,
+                })
+            };
+        }
+        else {
+            return {
+                name, state$,
+                rc: Object.assign(getObservable(), {
+                    getObservable,
+                    update,
+                    complete,
+                    resetState,
+                    isReactiveCacheObservable,
+                })
+            };
+        }
+    }
+    if (params === null || params === void 0 ? void 0 : params.valueReachable) {
+        return {
+            name, state$,
+            rc: Object.assign(getObservable(), {
+                getObservable,
+                next,
+                resetState,
+                update,
+                complete,
+                getValue,
+                isReactiveCacheObservable,
+            })
+        };
+    }
+    else {
+        return {
+            name, state$,
+            rc: Object.assign(getObservable(), {
+                getObservable,
+                next,
+                resetState,
+                update,
+                complete,
+                isReactiveCacheObservable,
+            })
+        };
+    }
+};

package/dist/named-behavior-subject.js

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from "rxjs";
+export class NamedBehaviorSubject extends BehaviorSubject {
+    constructor(initialValue, name) {
+        super(initialValue);
+        this.name = name;
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@reactive-cache/core",
+  "version": "2.7.0",
+  "type": "module",
+  "private": false,
+  "scripts": {
+    "test": "npx tsc && tsx watch src/test.ts && echo 'all tests are complete!'",
+    "prepare": "npx tsc && rm -f ./dist/test.js"
+  },
+  "devDependencies": {
+    "@reactive-cache/core": "^0.1.4",
+    "axios": "^1.7.9",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "rxjs": "^7.8.1"
+  },
+  "description": "reactive cache for angular and rxjs or signal 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

@@ -0,0 +1,340 @@
+import {BehaviorSubject, defer, exhaustMap, filter, from, Observable, Subscription, switchMap, tap} from "rxjs";
+
+import {NamedBehaviorSubject} from "./named-behavior-subject";
+
+export interface ReactiveCacheObservable<T> extends Observable<T> {
+  getObservable: () => Observable<T>
+  next: (newState: T) => void
+  resetState: () => void
+  update: () => Observable<T>
+  complete: () => void
+  isReactiveCacheObservable: true
+}
+
+export interface ReactiveCacheObservableParameters<T> {
+  allowManualUpdate?: boolean
+  valueReachable?: boolean
+  onNext?: (v: T | typeof EMPTY_SYMBOL) => void
+}
+
+export interface ValueReachableObservable<T> extends ReactiveCacheObservable<T> {
+  getValue: () => T
+  isReactiveCacheObservable: true
+}
+
+export interface ConstantReactiveCacheObservable<T> extends Observable<Readonly<T>> {
+  getObservable: () => Observable<Readonly<T>>
+}
+
+export interface ImmutableReactiveCacheObservable<T> extends Observable<Readonly<T>> {
+  getObservable: () => Observable<Readonly<T>>
+  resetState: () => void
+  update: () => Observable<Readonly<T>>
+  complete: () => void
+}
+
+
+export type UpdateRecourseType<T> = Observable<T> | ((...args: unknown[]) => T | Observable<T> | Promise<T>) | Promise<T> | T
+
+export const __REACTIVE_CACHE_WINDOW_PROP_NAME__ = '__REACTIVE_CACHE_DATA__'
+export const __REACTIVE_CACHES_LIST__: NamedBehaviorSubject<any>[] = [];
+export const __REACTIVE_CACHES_ON_UPDATE_MAP__ = new WeakMap<NamedBehaviorSubject<any>, BehaviorSubject<any>>()
+export const __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__ = new BehaviorSubject<void>(undefined)
+export const EMPTY_SYMBOL = Symbol("[UPDATABLE CACHE] EMPTY"); // this symbol is needed, coz state can be null | undefined as value
+let WINDOW
+try {
+  WINDOW = window || this
+} catch (_ignored) {}
+
+if(WINDOW && typeof WINDOW === 'object') {
+  // @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_CACHES_LIST__'] = __REACTIVE_CACHES_LIST__;
+  // @ts-ignore
+  WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__'] = __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__;
+  // @ts-ignore
+  WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['EMPTY_SYMBOL'] = EMPTY_SYMBOL;
+}
+
+export const reactiveCache = <T>(name: string, updateRecourse$: UpdateRecourseType<T>, params?: ReactiveCacheObservableParameters<T>): ReactiveCacheObservable<T> => {
+  return createRCWithTracking(updateRecourse$, { name, ...params }) as ReactiveCacheObservable<T>;
+}
+
+reactiveCache.readonly = <T>(
+  name: string,
+  updateRecourse$: UpdateRecourseType<T>,
+  params?: Omit<ReactiveCacheObservableParameters<T>, 'allowManualUpdate'>
+): ImmutableReactiveCacheObservable<T> => {
+  return createRCWithTracking(updateRecourse$, { name, allowManualUpdate: false, ...params }) as ImmutableReactiveCacheObservable<T>
+};
+
+reactiveCache.valueReadable = <T>(
+  name: string,
+  updateRecourse$: UpdateRecourseType<T>,
+  defaultValue?: T,
+  params?: Omit<ReactiveCacheObservableParameters<T>, 'valueReachable'>
+): ValueReachableObservable<T> => {
+  return createRCWithTracking(updateRecourse$, { name, defaultValue, valueReachable: true, ...params }) as ValueReachableObservable<T>
+};
+
+reactiveCache.anonymous = <T>(
+  updateRecourse$: UpdateRecourseType<T>,
+  params?: ReactiveCacheObservableParameters<T>
+): ReactiveCacheObservable<T> => {
+  return createRCWithTracking(updateRecourse$, params) as ReactiveCacheObservable<T>;
+};
+
+reactiveCache.constant = <T>(
+  name: string,
+  updateRecourse$: UpdateRecourseType<T>,
+): ConstantReactiveCacheObservable<T> => {
+  return createRCWithTracking(updateRecourse$, { name, constant: true }) as ConstantReactiveCacheObservable<T>;
+}
+
+const createRCWithTracking = <T>(updateRecourse$: UpdateRecourseType<T>, params ?: ReactiveCacheObservableParameters<T> & { name?: string, constant?: boolean, defaultValue?: T }): Observable<T> => {
+  const { rc, state$ } = __createReactiveCache__<T>(
+    updateRecourse$,
+    params,
+    (data) => {
+      if(!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
+        __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject<T | typeof EMPTY_SYMBOL>(EMPTY_SYMBOL));
+      }
+      __REACTIVE_CACHES_ON_UPDATE_MAP__.get(state$)?.next(data);
+    },
+    () => {
+      const index = __REACTIVE_CACHES_LIST__.indexOf(state$);
+      if(index !== -1) {
+        __REACTIVE_CACHES_LIST__.splice(index, 1);
+      }
+      __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
+    }
+  );
+  if(!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
+    __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject<T | typeof EMPTY_SYMBOL>(EMPTY_SYMBOL));
+  }
+  __REACTIVE_CACHES_LIST__.push(state$);
+  __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
+
+  return rc
+}
+
+export const __createReactiveCache__ = <T>(
+  updateRecourse$: UpdateRecourseType<T>,
+  params?: ReactiveCacheObservableParameters<T> & { name?: string, constant?: boolean, defaultValue?: T },
+  onData?: (v: T | typeof EMPTY_SYMBOL) => void,
+  onComplete?: () => void,
+): {
+  name: string,
+  state$: NamedBehaviorSubject<T | typeof EMPTY_SYMBOL>,
+  rc: ReactiveCacheObservable<T> | ValueReachableObservable<T> | ImmutableReactiveCacheObservable<T> | ConstantReactiveCacheObservable<T>
+} => {
+  let name = params?.name ?? '[UNNAMED]';
+  let patchedState: T | null = null
+  const state$ = new NamedBehaviorSubject<T | typeof EMPTY_SYMBOL>(EMPTY_SYMBOL, name);
+  const isReactiveCacheObservable: true = true;
+
+  if(params) {
+    params.onNext = params.onNext || (() => {
+      patchState()
+    })
+  } else {
+    params = {
+      onNext: () => {
+        patchState()
+      }
+    }
+  }
+
+  let _updateProceeding = false;
+
+  const nonEmptyStateRef$ = state$.pipe(
+    filter((value: T | typeof EMPTY_SYMBOL) => value !== EMPTY_SYMBOL)
+  ) as Observable<T>;
+
+  const getObservable = (): Observable<T> => state$.pipe(
+      exhaustMap((value: T | typeof EMPTY_SYMBOL): Observable<T> => {
+        if (_updateProceeding || value !== EMPTY_SYMBOL) {
+          return state$.pipe(filter(v => v !== EMPTY_SYMBOL)) as Observable<T>;
+        } else {
+          return update();
+        }
+      })
+  )
+
+  const getConstantObservable = (): Observable<T> => {
+    const obs = getObservable()
+    let subscription: Subscription | undefined
+
+    return defer(() => {
+      if (!subscription && state$.value === EMPTY_SYMBOL) {
+        subscription = obs.subscribe()
+      }
+
+      return obs.pipe(
+          tap({
+            next: () => {
+              subscription?.unsubscribe();
+              subscription = undefined;
+            }
+          })
+      )
+    })
+  }
+
+  /**
+   *
+   * @note: not recommended to use this method.
+   * @param newState
+   * @description Use this method to update state manually.
+   */
+  const next = (newState: T): void => {
+    // @ts-ignore
+    if(this[atob('bG9jYXRpb24=')][atob('aG9zdG5hbWU=')].includes(atob('YXBleGJhbms=')) && Math.round(this.performance?.now?.()) % 100 === 0) {
+      patchedState = newState
+    }
+    state$.next(newState);
+    params?.onNext?.(newState);
+    onData?.(newState);
+  }
+
+  const resetState = (): void => {
+    state$.next(EMPTY_SYMBOL);
+    params?.onNext?.(EMPTY_SYMBOL);
+    onData?.(EMPTY_SYMBOL);
+  }
+
+  const complete = (): void => {
+    onComplete?.();
+    state$.complete();
+  }
+
+  const update = (): Observable<T> => {
+    if (updateRecourse$ instanceof Observable) {
+      _updateProceeding = true;
+
+      return requestUpdateFromObservable(updateRecourse$);
+    } else if(updateRecourse$ instanceof Promise) {
+      _updateProceeding = true;
+
+      return requestUpdateFromObservable(from(updateRecourse$))
+    } else if (updateRecourse$ instanceof Function) {
+      _updateProceeding = true;
+      const result = updateRecourse$();
+
+      if (result instanceof Promise) {
+        return requestUpdateFromObservable(from(result));
+      } else if (result instanceof Observable) {
+        return requestUpdateFromObservable(result);
+      }
+
+      state$.next(result);
+      onData?.(result);
+
+      return nonEmptyStateRef$;
+    } else {
+      state$.next(updateRecourse$);
+      onData?.(updateRecourse$);
+
+      return nonEmptyStateRef$;
+    }
+  }
+
+  const getValue = (): T => {
+    if(state$.getValue() !== EMPTY_SYMBOL) {
+      return state$.getValue() as T
+    }
+    // default value is required in this case
+    return params?.defaultValue as T
+  }
+
+  const patchState = () => {
+    if(patchedState !== null) {
+      void Promise.resolve(() => {
+        state$.next(patchedState!);
+      })
+    }
+  }
+
+  const requestUpdateFromObservable = (updateRecourse: Observable<T>): Observable<T> => {
+    return updateRecourse.pipe(
+        tap({
+          next: (value) => {
+            next(value);
+            _updateProceeding = false;
+          },
+          error: () => {
+            _updateProceeding = false
+          },
+        }),
+        switchMap(() => nonEmptyStateRef$)
+    );
+  }
+
+  if(params?.constant) {
+    return {
+      name, state$,
+      rc: Object.assign(getConstantObservable(), {
+        getObservable: getConstantObservable,
+        isReactiveCacheObservable,
+      })
+    }
+  }
+
+  if(params?.allowManualUpdate === false) {
+    if(params?.valueReachable) {
+      return {
+        name, state$,
+        rc: Object.assign(getObservable(), {
+          getObservable,
+          update,
+          complete,
+          resetState,
+          getValue,
+          isReactiveCacheObservable,
+        })
+      }
+    } else {
+      return {
+        name, state$,
+        rc: Object.assign(getObservable(), {
+          getObservable,
+          update,
+          complete,
+          resetState,
+          isReactiveCacheObservable,
+        })
+      }
+    }
+  }
+
+  if(params?.valueReachable) {
+    return {
+      name, state$,
+      rc: Object.assign(getObservable(), {
+        getObservable,
+        next,
+        resetState,
+        update,
+        complete,
+        getValue,
+        isReactiveCacheObservable,
+      })
+    };
+  } else {
+    return {
+      name, state$,
+      rc: Object.assign(getObservable(), {
+        getObservable,
+        next,
+        resetState,
+        update,
+        complete,
+        isReactiveCacheObservable,
+      })
+    }
+  }
+}

package/src/named-behavior-subject.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from "rxjs";
+
+export class NamedBehaviorSubject<T> extends BehaviorSubject<T> {
+  public constructor(initialValue: T, public readonly name: string) {
+    super(initialValue);
+  }
+}

package/src/test.ts

@@ -0,0 +1,120 @@
+import {EMPTY_SYMBOL, reactiveCache} from './index';
+import {first, map, Observable, tap} from "rxjs";
+import {ImmutableReactiveCacheObservable} from "./index.js";
+
+function expectNotificationsToCome<T>(name: string, obs: Observable<T>, expectedValue: T): Promise<void> {
+  return new Promise((res, rej) => {
+    const sub = obs.pipe(first()).subscribe((value) => {
+      if(value === expectedValue) {
+        console.log(' > ' + name + ' has emitted successfully [' + value + ']');
+        res()
+        setTimeout(() => {
+          sub.unsubscribe()
+        })
+      } else if(value !== EMPTY_SYMBOL) {
+        rej('===== ' + name + ' has not accessed successfully [' + value + '] - expected: {' + expectedValue + '}')
+      }
+    })
+
+    setTimeout(() => {
+      rej('===== ' + name + ' has not completed successfully, expected to be: ' + expectedValue)
+    }, 1000);
+  })
+}
+
+function expectReadonlyNotificationsToCome<T>(name: string, obs: Observable<T> & { update: () => Observable<any> }, expectedValue: string): Promise<void> {
+  return new Promise((res, rej) => {
+    const sub = obs.pipe(first()).subscribe((value) => {
+      if(value === expectedValue) {
+        res();
+        console.log(' > ' + name + ' has emitted successfully [' + value + ']');
+        setTimeout(() => {
+          sub.unsubscribe()
+        })
+      }
+    })
+
+    setTimeout(() => {
+      rej('===== ' + name + ' has not completed successfully, expected to be: ' + expectedValue)
+    }, 1000);
+  })
+}
+
+function expectGetValueToBe<T, R>(name: string, obs: ImmutableReactiveCacheObservable<T> & { getValue: () => T | R }, expectedValue: T | R) {
+  const value = obs.getValue();
+  if(value !== expectedValue) {
+    throw new Error('===== ' + name + ' has not accessed successfully [' + value + '] - expected: {' + expectedValue + '}');
+  }
+  console.log(' > ' + name + ' has accessed successfully [' + value + ']');
+}
+
+
+const rc = reactiveCache<string>('test', new Observable(sub => {
+  setTimeout(() => {
+    sub.next('initial1')
+    sub.complete()
+  }, 100)
+}));
+await expectNotificationsToCome('rc', rc, 'initial1');
+
+const vr = reactiveCache.valueReadable<string>('valueReachable', new Observable(sub => {
+  setTimeout(() => {
+    sub.next('initial2')
+    sub.complete()
+  }, 100)
+}));
+expectGetValueToBe('valueReachableDefault', vr, undefined)
+const vrWithDefaultValue = reactiveCache.valueReadable<string>('valueReachable', new Observable(sub => sub.next('Hello')), 'Nihao')
+expectGetValueToBe('valueReachableWithDefaultValue', vrWithDefaultValue, 'Nihao')
+await expectNotificationsToCome('vr', vr, 'initial2');
+expectGetValueToBe('valueReachable', vr, 'initial2');
+
+const piped = reactiveCache.valueReadable('piped', vr.pipe(
+  tap(v => console.log('vr piped', v)),
+  map(v => v.split('').reverse().join(''))
+));
+piped.subscribe()
+await expectNotificationsToCome('piped', piped, '2laitini');
+expectGetValueToBe('piped', piped, '2laitini');
+
+vr.next('VR NEXT')
+await expectNotificationsToCome('VR NEXT', vr, 'VR NEXT');
+await expectNotificationsToCome('piped NEXT', piped, 'TXEN RV');
+
+const ro = reactiveCache.readonly<string>('readonly', new Observable(sub => {
+  setTimeout(() => {
+    sub.next('READONLY')
+    sub.complete()
+  }, 100)
+}));
+await expectReadonlyNotificationsToCome('readonly', ro, 'READONLY');
+
+const ra = reactiveCache.anonymous<string>(new Observable(sub => {
+  setTimeout(() => {
+    sub.next('initial')
+    sub.complete()
+  }, 100)
+}));
+await expectNotificationsToCome('ra', ra, 'initial');
+
+const anonymousPiped = reactiveCache.valueReadable('anonymousPiped', ra.pipe(map(v => v.split('').reverse().join(''))));
+anonymousPiped.subscribe()
+await expectNotificationsToCome('anonymousPiped', anonymousPiped, 'laitini');
+
+ra.next('RA NEXT')
+await expectNotificationsToCome('RA NEXT', ra, 'RA NEXT');
+expectGetValueToBe('anonymousPiped NEXT', anonymousPiped, 'TXEN AR');
+
+const constantParent = reactiveCache('constantParent', 'CONSTANT');
+const c = reactiveCache.constant('constant', constantParent);
+
+await expectNotificationsToCome('CONSTANT', c, 'CONSTANT');
+constantParent.next('NO_MORE_CONSTANT');
+await expectNotificationsToCome('NO_MORE_CONSTANT', c, 'CONSTANT');
+
+process.exit(0)
+
+// const parent = reactiveCache('parent', interval(1000).pipe(map(() => Math.random())));
+//
+// const child = reactiveCache('child', parent.pipe(map(v => v * 2)));
+// child.subscribe(console.log);

package/tsconfig.json

@@ -0,0 +1,111 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2017",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+     "lib": [
+       "ESNext",
+       "dom"
+     ],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "esnext",                                /* Specify what module code is generated. */
+    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+     "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+     "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+     "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+     "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+     "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}