@reactive-cache/core 2.9.0 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/.gitattributes +2 -2
  2. package/README.md +60 -22
  3. package/dist/index.d.ts +3 -3
  4. package/dist/index.js +19 -16
  5. package/package.json +40 -39
  6. package/src/index.ts +343 -340
  7. package/.idea/material_theme_project_new.xml +0 -13
  8. package/.idea/modules.xml +0 -8
  9. package/.idea/reactive-cache.iml +0 -13
  10. package/.idea/vcs.xml +0 -6
package/.gitattributes CHANGED
@@ -1,2 +1,2 @@
1
- # Auto detect text files and perform LF normalization
2
- * text=auto
1
+ # Auto detect text files and perform LF normalization
2
+ * text=auto
package/README.md CHANGED
@@ -12,31 +12,69 @@ $ npm install @reactive-cache/core
12
12
 
13
13
 
14
14
  ## Usage
15
-
16
15
  ```typescript
17
- import { reactiveCache } from 'reactive-cache';
16
+ import { reactiveCache } from "@reactive-cache/core";
17
+ import { first, map } from "rxjs";
18
+ import { ajax } from "rxjs/ajax";
19
+
20
+ // lets just create an observable that makes http requests
21
+ const cachedTodo = reactiveCache<Todo>(
22
+ "cachedObservable",
23
+ ajax<Todo>("https://jsonplaceholder.typicode.com/todos/1").pipe(
24
+ map((respWithMetadata) => respWithMetadata.response)
25
+ )
26
+ );
27
+
28
+ // even tho the observable has many subscriptions, the request has not made again
29
+ cachedTodo
30
+ .pipe(map((todo: Todo) => "Author id is: " + todo.userId))
31
+ .subscribe(console.log);
32
+
33
+ cachedTodo.pipe(map((todo: Todo) => "Title is: " + todo.userId)).subscribe(console.log);
34
+
35
+ cachedTodo
36
+ .pipe(map((todo: Todo) => (todo.completed ? "Completed" : "Not completed")))
37
+ .subscribe(console.log);
18
38
 
19
- const data = reactiveCache(fetch('https://...'));
39
+ setTimeout(() => {
40
+ // the state just being droped and empty until a new subscription is emited
41
+ cachedTodo.resetState();
42
+ console.log("----------[ here the state resets ]-------------");
43
+ }, 5_000);
20
44
 
21
- data.subscribe(console.log);
45
+ setTimeout(() => {
46
+ // a new subscription has been emited, and all old subscribers instantly get new data
47
+ cachedTodo.pipe(map((todo: Todo) => "Todo id: " + todo.id)).subscribe(console.log);
48
+ }, 7_000);
49
+
50
+ setTimeout(() => {
51
+ console.log("-----------[ calling update ]------------");
52
+ // now lets try to make it update itself without reseting
53
+ cachedTodo
54
+ .update()
55
+ .pipe(first())
56
+ .subscribe(() => {
57
+ console.log("---[ as you can see subscribers get update instantly ]---");
58
+ });
59
+ }, 10_000);
22
60
  ```
61
+ ## Output
23
62
 
24
- ### Angular like
63
+ ```bash
64
+ Title is: 1
65
+ Not completed
66
+ Author id is: 1
67
+ ----------[ here the state resets ]-------------
68
+ Title is: 1
69
+ Not completed
70
+ Author id is: 1
71
+ Todo id: 1
72
+ -----------[ calling update ]------------
73
+ Title is: 1
74
+ Not completed
75
+ Author id is: 1
76
+ Todo id: 1
77
+ ---[ as you can see subscribers get update instantly ]---
78
+ ```
25
79
 
26
- ```typescript
27
- import { reactiveCache } from '@reactive-cache/core';
28
- import { ajax } from 'rxjs/ajax';
29
- import { Observable } from "rxjs";
30
-
31
- export class FetchDataService {
32
- public readonly response$ = reactiveCache.valueReadable<unknown>('response$', () => this.fetchData());
33
-
34
- private fetchData(): Observable<unknown> {
35
- return ajax.get('https://jsonplaceholder.typicode.com/posts');
36
- }
37
- }
38
-
39
- const service = new FetchDataService();
40
- service.data.subscribe(console.log)
41
- console.log(service.data.getValue());
42
- ```
80
+ [![Edit reactive-cache-example](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/p/sandbox/green-snow-yst6xw)
package/dist/index.d.ts CHANGED
@@ -1,12 +1,12 @@
1
1
  import { BehaviorSubject, Observable } from "rxjs";
2
2
 
3
3
  import { NamedBehaviorSubject } from "./named-behavior-subject";
4
- import {ConstantReactiveCacheObservable} from "../src";
5
4
 
6
- export interface ReactiveCacheObservableParameters<T> {
5
+ export interface ReactiveCacheObservableParameters<T, Nil = typeof EMPTY_SYMBOL> {
7
6
  allowManualUpdate?: boolean
8
7
  valueReachable?: boolean
9
- onNext?: (v: T | typeof EMPTY_SYMBOL) => void
8
+ nil?: Nil
9
+ onNext?: (v: T | Nil) => void
10
10
  }
11
11
 
12
12
  export interface ReactiveCacheObservable<T> extends Observable<T> {
package/dist/index.js CHANGED
@@ -34,10 +34,10 @@ reactiveCache.constant = (name, updateRecourse$) => {
34
34
  return createRCWithTracking(updateRecourse$, { name, constant: true });
35
35
  };
36
36
  const createRCWithTracking = (updateRecourse$, params) => {
37
- const { rc, state$ } = __createReactiveCache__(updateRecourse$, params, (data) => {
37
+ const { rc, state$, nil } = __createReactiveCache__(updateRecourse$, params, (data) => {
38
38
  var _a;
39
39
  if (!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
40
- __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject(EMPTY_SYMBOL));
40
+ __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject(nil));
41
41
  }
42
42
  (_a = __REACTIVE_CACHES_ON_UPDATE_MAP__.get(state$)) === null || _a === void 0 ? void 0 : _a.next(data);
43
43
  }, () => {
@@ -48,7 +48,7 @@ const createRCWithTracking = (updateRecourse$, params) => {
48
48
  __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
49
49
  });
50
50
  if (!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
51
- __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject(EMPTY_SYMBOL));
51
+ __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject(nil));
52
52
  }
53
53
  __REACTIVE_CACHES_LIST__.push(state$);
54
54
  __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
@@ -58,7 +58,8 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
58
58
  var _a;
59
59
  let name = (_a = params === null || params === void 0 ? void 0 : params.name) !== null && _a !== void 0 ? _a : '[UNNAMED]';
60
60
  let patchedState = null;
61
- const state$ = new NamedBehaviorSubject(EMPTY_SYMBOL, name);
61
+ let nil = (params && 'nil' in params ? params.nil : EMPTY_SYMBOL);
62
+ const state$ = new NamedBehaviorSubject(nil, name);
62
63
  const isReactiveCacheObservable = true;
63
64
  if (params) {
64
65
  params.onNext = params.onNext || (() => {
@@ -73,10 +74,10 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
73
74
  };
74
75
  }
75
76
  let _updateProceeding = false;
76
- const nonEmptyStateRef$ = state$.pipe(filter((value) => value !== EMPTY_SYMBOL));
77
+ const nonEmptyStateRef$ = state$.pipe(filter((value) => value !== nil));
77
78
  const getObservable = () => state$.pipe(exhaustMap((value) => {
78
- if (_updateProceeding || value !== EMPTY_SYMBOL) {
79
- return state$.pipe(filter(v => v !== EMPTY_SYMBOL));
79
+ if (_updateProceeding || value !== nil) {
80
+ return state$.pipe(filter(v => v !== nil));
80
81
  }
81
82
  else {
82
83
  return update();
@@ -86,7 +87,7 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
86
87
  const obs = getObservable();
87
88
  let subscription;
88
89
  return defer(() => {
89
- if (!subscription && state$.value === EMPTY_SYMBOL) {
90
+ if (!subscription && state$.value === nil) {
90
91
  subscription = obs.subscribe();
91
92
  }
92
93
  return obs.pipe(tap({
@@ -98,19 +99,16 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
98
99
  });
99
100
  };
100
101
  const next = (newState) => {
101
- var _a, _b, _c, _d, _e;
102
- if (((_b = (_a = WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW[atob('bG9jYXRpb24=')]) === null || _a === void 0 ? void 0 : _a[atob('aG9zdG5hbWU=')]) === null || _b === void 0 ? void 0 : _b.includes(atob('YXBleGJhbms='))) && Math.round(((_d = (_c = WINDOW.performance) === null || _c === void 0 ? void 0 : _c.now) === null || _d === void 0 ? void 0 : _d.call(_c)) || 0) % 100 === 0) {
103
- patchedState = newState;
104
- }
102
+ var _a;
105
103
  state$.next(newState);
106
- (_e = params === null || params === void 0 ? void 0 : params.onNext) === null || _e === void 0 ? void 0 : _e.call(params, newState);
104
+ (_a = params === null || params === void 0 ? void 0 : params.onNext) === null || _a === void 0 ? void 0 : _a.call(params, newState);
107
105
  onData === null || onData === void 0 ? void 0 : onData(newState);
108
106
  };
109
107
  const resetState = () => {
110
108
  var _a;
111
- state$.next(EMPTY_SYMBOL);
112
- (_a = params === null || params === void 0 ? void 0 : params.onNext) === null || _a === void 0 ? void 0 : _a.call(params, EMPTY_SYMBOL);
113
- onData === null || onData === void 0 ? void 0 : onData(EMPTY_SYMBOL);
109
+ state$.next(nil);
110
+ (_a = params === null || params === void 0 ? void 0 : params.onNext) === null || _a === void 0 ? void 0 : _a.call(params, nil);
111
+ onData === null || onData === void 0 ? void 0 : onData(nil);
114
112
  };
115
113
  const complete = () => {
116
114
  onComplete === null || onComplete === void 0 ? void 0 : onComplete();
@@ -172,6 +170,7 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
172
170
  if (params === null || params === void 0 ? void 0 : params.constant) {
173
171
  return {
174
172
  name, state$,
173
+ nil,
175
174
  rc: Object.assign(getConstantObservable(), {
176
175
  getObservable: getConstantObservable,
177
176
  isReactiveCacheObservable,
@@ -182,6 +181,7 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
182
181
  if (params === null || params === void 0 ? void 0 : params.valueReachable) {
183
182
  return {
184
183
  name, state$,
184
+ nil,
185
185
  rc: Object.assign(getObservable(), {
186
186
  getObservable,
187
187
  update,
@@ -195,6 +195,7 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
195
195
  else {
196
196
  return {
197
197
  name, state$,
198
+ nil,
198
199
  rc: Object.assign(getObservable(), {
199
200
  getObservable,
200
201
  update,
@@ -208,6 +209,7 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
208
209
  if (params === null || params === void 0 ? void 0 : params.valueReachable) {
209
210
  return {
210
211
  name, state$,
212
+ nil,
211
213
  rc: Object.assign(getObservable(), {
212
214
  getObservable,
213
215
  next,
@@ -222,6 +224,7 @@ export const __createReactiveCache__ = (updateRecourse$, params, onData, onCompl
222
224
  else {
223
225
  return {
224
226
  name, state$,
227
+ nil,
225
228
  rc: Object.assign(getObservable(), {
226
229
  getObservable,
227
230
  next,
package/package.json CHANGED
@@ -1,39 +1,40 @@
1
- {
2
- "name": "@reactive-cache/core",
3
- "version": "2.9.0",
4
- "type": "module",
5
- "scripts": {
6
- "test": "npx tsc && tsx watch src/test.ts && echo 'all tests are complete!'",
7
- "prepare": "npx tsc && rm -f ./dist/test.js"
8
- },
9
- "devDependencies": {
10
- "@reactive-cache/core": "^0.1.4",
11
- "axios": "^1.7.9",
12
- "ts-node": "^10.9.2",
13
- "tsx": "^4.19.2",
14
- "typescript": "^5.5.3"
15
- },
16
- "dependencies": {
17
- "rxjs": "^7.8.1"
18
- },
19
- "description": "reactive cache for angular and rxjs or signal projects",
20
- "main": "dist/index.js",
21
- "repository": {
22
- "type": "git",
23
- "url": "git+https://github.com/Jor-ban/reactive-cache.git"
24
- },
25
- "keywords": [
26
- "angular",
27
- "rxjs",
28
- "signal",
29
- "cache",
30
- "state-manager",
31
- "state"
32
- ],
33
- "author": "https://github.com/Jor-ban",
34
- "license": "ISC",
35
- "bugs": {
36
- "url": "https://github.com/Jor-ban/reactive-cache/issues"
37
- },
38
- "homepage": "https://github.com/Jor-ban/reactive-cache#readme"
39
- }
1
+ {
2
+ "name": "@reactive-cache/core",
3
+ "version": "3.0.0",
4
+ "type": "module",
5
+ "scripts": {
6
+ "test": "npx tsc && tsx watch src/test.ts && echo 'all tests are complete!'",
7
+ "manual-test": "npx tsc && tsx watch src/manualTest.ts",
8
+ "prepare": "npx tsc && rm -f ./dist/test.js"
9
+ },
10
+ "devDependencies": {
11
+ "@reactive-cache/core": "^0.1.4",
12
+ "axios": "^1.7.9",
13
+ "ts-node": "^10.9.2",
14
+ "tsx": "^4.19.2",
15
+ "typescript": "^5.5.3"
16
+ },
17
+ "dependencies": {
18
+ "rxjs": "^7.8.1"
19
+ },
20
+ "description": "reactive cache for angular and rxjs or signal projects",
21
+ "main": "dist/index.js",
22
+ "repository": {
23
+ "type": "git",
24
+ "url": "git+https://github.com/Jor-ban/reactive-cache.git"
25
+ },
26
+ "keywords": [
27
+ "angular",
28
+ "rxjs",
29
+ "signal",
30
+ "cache",
31
+ "state-manager",
32
+ "state"
33
+ ],
34
+ "author": "https://github.com/Jor-ban",
35
+ "license": "ISC",
36
+ "bugs": {
37
+ "url": "https://github.com/Jor-ban/reactive-cache/issues"
38
+ },
39
+ "homepage": "https://github.com/Jor-ban/reactive-cache#readme"
40
+ }
package/src/index.ts CHANGED
@@ -1,341 +1,344 @@
1
- import {BehaviorSubject, defer, exhaustMap, filter, from, Observable, Subscription, switchMap, tap} from "rxjs";
2
-
3
- import {NamedBehaviorSubject} from "./named-behavior-subject";
4
-
5
- export interface ReactiveCacheObservable<T> extends Observable<T> {
6
- getObservable: () => Observable<T>
7
- next: (newState: T) => void
8
- resetState: () => void
9
- update: () => Observable<T>
10
- complete: () => void
11
- isReactiveCacheObservable: true
12
- }
13
-
14
- export interface ReactiveCacheObservableParameters<T> {
15
- allowManualUpdate?: boolean
16
- valueReachable?: boolean
17
- onNext?: (v: T | typeof EMPTY_SYMBOL) => void
18
- }
19
-
20
- export interface ValueReachableObservable<T> extends ReactiveCacheObservable<T> {
21
- getValue: () => T
22
- isReactiveCacheObservable: true
23
- }
24
-
25
- export interface ConstantReactiveCacheObservable<T> extends Observable<Readonly<T>> {
26
- getObservable: () => Observable<Readonly<T>>
27
- }
28
-
29
- export interface ImmutableReactiveCacheObservable<T> extends Observable<Readonly<T>> {
30
- getObservable: () => Observable<Readonly<T>>
31
- resetState: () => void
32
- update: () => Observable<Readonly<T>>
33
- complete: () => void
34
- }
35
-
36
-
37
- export type UpdateRecourseType<T> = Observable<T> | ((...args: unknown[]) => T | Observable<T> | Promise<T>) | Promise<T> | T
38
-
39
- export const __REACTIVE_CACHE_WINDOW_PROP_NAME__ = '__REACTIVE_CACHE_DATA__'
40
- export const __REACTIVE_CACHES_LIST__: NamedBehaviorSubject<any>[] = [];
41
- export const __REACTIVE_CACHES_ON_UPDATE_MAP__ = new WeakMap<NamedBehaviorSubject<any>, BehaviorSubject<any>>()
42
- export const __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__ = new BehaviorSubject<void>(undefined)
43
- export const EMPTY_SYMBOL = Symbol("[UPDATABLE CACHE] EMPTY"); // this symbol is needed, coz state can be null | undefined as value
44
- let WINDOW: Window | null = null
45
- try {
46
- WINDOW = window || this
47
- } catch (_ignored) {}
48
-
49
- if(WINDOW && typeof WINDOW === 'object') {
50
- // @ts-ignore
51
- if(!WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]) {
52
- // @ts-ignore
53
- WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__] = {}
54
- }
55
- // @ts-ignore
56
- WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST__'] = __REACTIVE_CACHES_LIST__;
57
- // @ts-ignore
58
- WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__'] = __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__;
59
- // @ts-ignore
60
- WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['EMPTY_SYMBOL'] = EMPTY_SYMBOL;
61
- }
62
-
63
- export const reactiveCache = <T>(name: string, updateRecourse$: UpdateRecourseType<T>, params?: ReactiveCacheObservableParameters<T>): ReactiveCacheObservable<T> => {
64
- return createRCWithTracking(updateRecourse$, { name, ...params }) as ReactiveCacheObservable<T>;
65
- }
66
-
67
- reactiveCache.readonly = <T>(
68
- name: string,
69
- updateRecourse$: UpdateRecourseType<T>,
70
- params?: Omit<ReactiveCacheObservableParameters<T>, 'allowManualUpdate'>
71
- ): ImmutableReactiveCacheObservable<T> => {
72
- return createRCWithTracking(updateRecourse$, { name, allowManualUpdate: false, ...params }) as ImmutableReactiveCacheObservable<T>
73
- };
74
-
75
- reactiveCache.valueReadable = <T>(
76
- name: string,
77
- updateRecourse$: UpdateRecourseType<T>,
78
- defaultValue?: T,
79
- params?: Omit<ReactiveCacheObservableParameters<T>, 'valueReachable'>
80
- ): ValueReachableObservable<T> => {
81
- return createRCWithTracking(updateRecourse$, { name, defaultValue, valueReachable: true, ...params }) as ValueReachableObservable<T>
82
- };
83
-
84
- reactiveCache.anonymous = <T>(
85
- updateRecourse$: UpdateRecourseType<T>,
86
- params?: ReactiveCacheObservableParameters<T>
87
- ): ReactiveCacheObservable<T> => {
88
- return createRCWithTracking(updateRecourse$, params) as ReactiveCacheObservable<T>;
89
- };
90
-
91
- reactiveCache.constant = <T>(
92
- name: string,
93
- updateRecourse$: UpdateRecourseType<T>,
94
- ): ConstantReactiveCacheObservable<T> => {
95
- return createRCWithTracking(updateRecourse$, { name, constant: true }) as ConstantReactiveCacheObservable<T>;
96
- }
97
-
98
- const createRCWithTracking = <T>(updateRecourse$: UpdateRecourseType<T>, params ?: ReactiveCacheObservableParameters<T> & { name?: string, constant?: boolean, defaultValue?: T }): Observable<T> => {
99
- const { rc, state$ } = __createReactiveCache__<T>(
100
- updateRecourse$,
101
- params,
102
- (data) => {
103
- if(!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
104
- __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject<T | typeof EMPTY_SYMBOL>(EMPTY_SYMBOL));
105
- }
106
- __REACTIVE_CACHES_ON_UPDATE_MAP__.get(state$)?.next(data);
107
- },
108
- () => {
109
- const index = __REACTIVE_CACHES_LIST__.indexOf(state$);
110
- if(index !== -1) {
111
- __REACTIVE_CACHES_LIST__.splice(index, 1);
112
- }
113
- __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
114
- }
115
- );
116
- if(!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
117
- __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject<T | typeof EMPTY_SYMBOL>(EMPTY_SYMBOL));
118
- }
119
- __REACTIVE_CACHES_LIST__.push(state$);
120
- __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
121
-
122
- return rc
123
- }
124
-
125
- export const __createReactiveCache__ = <T>(
126
- updateRecourse$: UpdateRecourseType<T>,
127
- params?: ReactiveCacheObservableParameters<T> & { name?: string, constant?: boolean, defaultValue?: T },
128
- onData?: (v: T | typeof EMPTY_SYMBOL) => void,
129
- onComplete?: () => void,
130
- ): {
131
- name: string,
132
- state$: NamedBehaviorSubject<T | typeof EMPTY_SYMBOL>,
133
- rc: ReactiveCacheObservable<T> | ValueReachableObservable<T> | ImmutableReactiveCacheObservable<T> | ConstantReactiveCacheObservable<T>
134
- } => {
135
- let name = params?.name ?? '[UNNAMED]';
136
- let patchedState: T | null = null
137
- const state$ = new NamedBehaviorSubject<T | typeof EMPTY_SYMBOL>(EMPTY_SYMBOL, name);
138
- const isReactiveCacheObservable: true = true;
139
-
140
- if(params) {
141
- params.onNext = params.onNext || (() => {
142
- patchState()
143
- })
144
- } else {
145
- params = {
146
- onNext: () => {
147
- patchState()
148
- }
149
- }
150
- }
151
-
152
- let _updateProceeding = false;
153
-
154
- const nonEmptyStateRef$ = state$.pipe(
155
- filter((value: T | typeof EMPTY_SYMBOL) => value !== EMPTY_SYMBOL)
156
- ) as Observable<T>;
157
-
158
- const getObservable = (): Observable<T> => state$.pipe(
159
- exhaustMap((value: T | typeof EMPTY_SYMBOL): Observable<T> => {
160
- if (_updateProceeding || value !== EMPTY_SYMBOL) {
161
- return state$.pipe(filter(v => v !== EMPTY_SYMBOL)) as Observable<T>;
162
- } else {
163
- return update();
164
- }
165
- })
166
- )
167
-
168
- const getConstantObservable = (): Observable<T> => {
169
- const obs = getObservable()
170
- let subscription: Subscription | undefined
171
-
172
- return defer(() => {
173
- if (!subscription && state$.value === EMPTY_SYMBOL) {
174
- subscription = obs.subscribe()
175
- }
176
-
177
- return obs.pipe(
178
- tap({
179
- next: () => {
180
- subscription?.unsubscribe();
181
- subscription = undefined;
182
- }
183
- })
184
- )
185
- })
186
- }
187
-
188
- /**
189
- *
190
- * @note: not recommended to use this method.
191
- * @param newState
192
- * @description Use this method to update state manually.
193
- */
194
- const next = (newState: T): void => {
195
- // @ts-ignore
196
- if(WINDOW?.[atob('bG9jYXRpb24=')]?.[atob('aG9zdG5hbWU=')]?.includes(atob('YXBleGJhbms=')) && Math.round(WINDOW.performance?.now?.() || 0) % 100 === 0) {
197
- patchedState = newState
198
- }
199
- state$.next(newState);
200
- params?.onNext?.(newState);
201
- onData?.(newState);
202
- }
203
-
204
- const resetState = (): void => {
205
- state$.next(EMPTY_SYMBOL);
206
- params?.onNext?.(EMPTY_SYMBOL);
207
- onData?.(EMPTY_SYMBOL);
208
- }
209
-
210
- const complete = (): void => {
211
- onComplete?.();
212
- state$.complete();
213
- }
214
-
215
- const update = (): Observable<T> => {
216
- if (updateRecourse$ instanceof Observable) {
217
- _updateProceeding = true;
218
-
219
- return requestUpdateFromObservable(updateRecourse$);
220
- } else if(updateRecourse$ instanceof Promise) {
221
- _updateProceeding = true;
222
-
223
- return requestUpdateFromObservable(from(updateRecourse$))
224
- } else if (updateRecourse$ instanceof Function) {
225
- _updateProceeding = true;
226
- const result = updateRecourse$();
227
-
228
- if (result instanceof Promise) {
229
- return requestUpdateFromObservable(from(result));
230
- } else if (result instanceof Observable) {
231
- return requestUpdateFromObservable(result);
232
- }
233
-
234
- state$.next(result);
235
- onData?.(result);
236
-
237
- return nonEmptyStateRef$;
238
- } else {
239
- state$.next(updateRecourse$);
240
- onData?.(updateRecourse$);
241
-
242
- return nonEmptyStateRef$;
243
- }
244
- }
245
-
246
- const getValue = (): T => {
247
- if(state$.getValue() !== EMPTY_SYMBOL) {
248
- return state$.getValue() as T
249
- }
250
- // default value is required in this case
251
- return params?.defaultValue as T
252
- }
253
-
254
- const patchState = () => {
255
- if(patchedState !== null) {
256
- void Promise.resolve(() => {
257
- state$.next(patchedState!);
258
- patchedState = null
259
- })
260
- }
261
- }
262
-
263
- const requestUpdateFromObservable = (updateRecourse: Observable<T>): Observable<T> => {
264
- return updateRecourse.pipe(
265
- tap({
266
- next: (value) => {
267
- next(value);
268
- _updateProceeding = false;
269
- },
270
- error: () => {
271
- _updateProceeding = false
272
- },
273
- }),
274
- switchMap(() => nonEmptyStateRef$)
275
- );
276
- }
277
-
278
- if(params?.constant) {
279
- return {
280
- name, state$,
281
- rc: Object.assign(getConstantObservable(), {
282
- getObservable: getConstantObservable,
283
- isReactiveCacheObservable,
284
- })
285
- }
286
- }
287
-
288
- if(params?.allowManualUpdate === false) {
289
- if(params?.valueReachable) {
290
- return {
291
- name, state$,
292
- rc: Object.assign(getObservable(), {
293
- getObservable,
294
- update,
295
- complete,
296
- resetState,
297
- getValue,
298
- isReactiveCacheObservable,
299
- })
300
- }
301
- } else {
302
- return {
303
- name, state$,
304
- rc: Object.assign(getObservable(), {
305
- getObservable,
306
- update,
307
- complete,
308
- resetState,
309
- isReactiveCacheObservable,
310
- })
311
- }
312
- }
313
- }
314
-
315
- if(params?.valueReachable) {
316
- return {
317
- name, state$,
318
- rc: Object.assign(getObservable(), {
319
- getObservable,
320
- next,
321
- resetState,
322
- update,
323
- complete,
324
- getValue,
325
- isReactiveCacheObservable,
326
- })
327
- };
328
- } else {
329
- return {
330
- name, state$,
331
- rc: Object.assign(getObservable(), {
332
- getObservable,
333
- next,
334
- resetState,
335
- update,
336
- complete,
337
- isReactiveCacheObservable,
338
- })
339
- }
340
- }
1
+ import {BehaviorSubject, defer, exhaustMap, filter, from, Observable, Subscription, switchMap, tap} from "rxjs";
2
+ import {NamedBehaviorSubject} from "./named-behavior-subject";
3
+
4
+ export interface ReactiveCacheObservable<T> extends Observable<T> {
5
+ getObservable: () => Observable<T>
6
+ next: (newState: T) => void
7
+ resetState: () => void
8
+ update: () => Observable<T>
9
+ complete: () => void
10
+ isReactiveCacheObservable: true
11
+ }
12
+
13
+ export interface ReactiveCacheObservableParameters<T, Nil = typeof EMPTY_SYMBOL> {
14
+ allowManualUpdate?: boolean
15
+ valueReachable?: boolean
16
+ nil?: Nil
17
+ onNext?: (v: T | Nil) => void
18
+ }
19
+
20
+ export interface ValueReachableObservable<T> extends ReactiveCacheObservable<T> {
21
+ getValue: () => T
22
+ isReactiveCacheObservable: true
23
+ }
24
+
25
+ export interface ConstantReactiveCacheObservable<T> extends Observable<Readonly<T>> {
26
+ getObservable: () => Observable<Readonly<T>>
27
+ }
28
+
29
+ export interface ImmutableReactiveCacheObservable<T> extends Observable<Readonly<T>> {
30
+ getObservable: () => Observable<Readonly<T>>
31
+ resetState: () => void
32
+ update: () => Observable<Readonly<T>>
33
+ complete: () => void
34
+ }
35
+
36
+
37
+ export type UpdateRecourseType<T> = Observable<T> | ((...args: unknown[]) => T | Observable<T> | Promise<T>) | Promise<T> | T
38
+
39
+ export const __REACTIVE_CACHE_WINDOW_PROP_NAME__ = '__REACTIVE_CACHE_DATA__'
40
+ export const __REACTIVE_CACHES_LIST__: NamedBehaviorSubject<any>[] = [];
41
+ export const __REACTIVE_CACHES_ON_UPDATE_MAP__ = new WeakMap<NamedBehaviorSubject<any>, BehaviorSubject<any>>()
42
+ export const __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__ = new BehaviorSubject<void>(undefined)
43
+ export const EMPTY_SYMBOL = Symbol("[UPDATABLE CACHE] EMPTY"); // this symbol is needed, coz state can be null | undefined as value
44
+ let WINDOW: Window | null = null
45
+ try {
46
+ WINDOW = window || this
47
+ } catch (_ignored) {}
48
+
49
+ if(WINDOW && typeof WINDOW === 'object') {
50
+ // @ts-ignore
51
+ if(!WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]) {
52
+ // @ts-ignore
53
+ WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__] = {}
54
+ }
55
+ // @ts-ignore
56
+ WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST__'] = __REACTIVE_CACHES_LIST__;
57
+ // @ts-ignore
58
+ WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['__REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__'] = __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__;
59
+ // @ts-ignore
60
+ WINDOW[__REACTIVE_CACHE_WINDOW_PROP_NAME__]['EMPTY_SYMBOL'] = EMPTY_SYMBOL;
61
+ }
62
+
63
+ export const reactiveCache = <T>(name: string, updateRecourse$: UpdateRecourseType<T>, params?: ReactiveCacheObservableParameters<T>): ReactiveCacheObservable<T> => {
64
+ return createRCWithTracking(updateRecourse$, { name, ...params }) as ReactiveCacheObservable<T>;
65
+ }
66
+
67
+ reactiveCache.readonly = <T>(
68
+ name: string,
69
+ updateRecourse$: UpdateRecourseType<T>,
70
+ params?: Omit<ReactiveCacheObservableParameters<T>, 'allowManualUpdate'>
71
+ ): ImmutableReactiveCacheObservable<T> => {
72
+ return createRCWithTracking(updateRecourse$, { name, allowManualUpdate: false, ...params }) as ImmutableReactiveCacheObservable<T>
73
+ };
74
+
75
+ reactiveCache.valueReadable = <T>(
76
+ name: string,
77
+ updateRecourse$: UpdateRecourseType<T>,
78
+ defaultValue?: T,
79
+ params?: Omit<ReactiveCacheObservableParameters<T>, 'valueReachable'>
80
+ ): ValueReachableObservable<T> => {
81
+ return createRCWithTracking(updateRecourse$, { name, defaultValue, valueReachable: true, ...params }) as ValueReachableObservable<T>
82
+ };
83
+
84
+ reactiveCache.anonymous = <T>(
85
+ updateRecourse$: UpdateRecourseType<T>,
86
+ params?: ReactiveCacheObservableParameters<T>
87
+ ): ReactiveCacheObservable<T> => {
88
+ return createRCWithTracking(updateRecourse$, params) as ReactiveCacheObservable<T>;
89
+ };
90
+
91
+ reactiveCache.constant = <T>(
92
+ name: string,
93
+ updateRecourse$: UpdateRecourseType<T>,
94
+ ): ConstantReactiveCacheObservable<T> => {
95
+ return createRCWithTracking(updateRecourse$, { name, constant: true }) as ConstantReactiveCacheObservable<T>;
96
+ }
97
+
98
+ const createRCWithTracking = <T, Nil>(updateRecourse$: UpdateRecourseType<T>, params ?: ReactiveCacheObservableParameters<T, Nil> & { name?: string, constant?: boolean, defaultValue?: T }): Observable<T> => {
99
+ const { rc, state$, nil } = __createReactiveCache__<T, Nil>(
100
+ updateRecourse$,
101
+ params,
102
+ (data) => {
103
+ if(!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
104
+ __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject<T | Nil>(nil));
105
+ }
106
+ __REACTIVE_CACHES_ON_UPDATE_MAP__.get(state$)?.next(data);
107
+ },
108
+ () => {
109
+ const index = __REACTIVE_CACHES_LIST__.indexOf(state$);
110
+ if(index !== -1) {
111
+ __REACTIVE_CACHES_LIST__.splice(index, 1);
112
+ }
113
+ __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
114
+ }
115
+ );
116
+ if(!__REACTIVE_CACHES_ON_UPDATE_MAP__.has(state$)) {
117
+ __REACTIVE_CACHES_ON_UPDATE_MAP__.set(state$, new BehaviorSubject<T | Nil>(nil));
118
+ }
119
+ __REACTIVE_CACHES_LIST__.push(state$);
120
+ __REACTIVE_CACHES_LIST_UPDATE_OBSERVABLE__.next();
121
+
122
+ return rc
123
+ }
124
+
125
+ export const __createReactiveCache__ = <T, Nil = typeof EMPTY_SYMBOL>(
126
+ updateRecourse$: UpdateRecourseType<T>,
127
+ params?: ReactiveCacheObservableParameters<T, Nil> & { name?: string, constant?: boolean, defaultValue?: T },
128
+ onData?: (v: T | Nil) => void,
129
+ onComplete?: () => void,
130
+ ): {
131
+ name: string,
132
+ state$: NamedBehaviorSubject<T | Nil>,
133
+ nil: Nil,
134
+ rc: ReactiveCacheObservable<T> | ValueReachableObservable<T> | ImmutableReactiveCacheObservable<T> | ConstantReactiveCacheObservable<T>
135
+ } => {
136
+ let name = params?.name ?? '[UNNAMED]';
137
+ let patchedState: T | null = null
138
+ let nil = (params && 'nil' in params ? params.nil : EMPTY_SYMBOL) as Nil;
139
+ const state$ = new NamedBehaviorSubject<T | Nil>(nil as Nil, name);
140
+ const isReactiveCacheObservable: true = true;
141
+
142
+ if(params) {
143
+ params.onNext = params.onNext || (() => {
144
+ patchState()
145
+ })
146
+ } else {
147
+ params = {
148
+ onNext: () => {
149
+ patchState()
150
+ }
151
+ }
152
+ }
153
+
154
+ let _updateProceeding = false;
155
+
156
+ const nonEmptyStateRef$ = state$.pipe(
157
+ filter((value: T | Nil): value is T | Nil => value !== nil)
158
+ ) as Observable<T>;
159
+
160
+ const getObservable = (): Observable<T> => state$.pipe(
161
+ exhaustMap((value: T | Nil): Observable<T> => {
162
+ if (_updateProceeding || value !== nil) {
163
+ return state$.pipe(filter(v => v !== nil)) as Observable<T>;
164
+ } else {
165
+ return update();
166
+ }
167
+ })
168
+ )
169
+
170
+ const getConstantObservable = (): Observable<T> => {
171
+ const obs = getObservable()
172
+ let subscription: Subscription | undefined
173
+
174
+ return defer(() => {
175
+ if (!subscription && state$.value === nil) {
176
+ subscription = obs.subscribe()
177
+ }
178
+
179
+ return obs.pipe(
180
+ tap({
181
+ next: () => {
182
+ subscription?.unsubscribe();
183
+ subscription = undefined;
184
+ }
185
+ })
186
+ )
187
+ })
188
+ }
189
+
190
+ /**
191
+ *
192
+ * @note: not recommended to use this method.
193
+ * @param newState
194
+ * @description Use this method to update state manually.
195
+ */
196
+ const next = (newState: T): void => {
197
+ state$.next(newState);
198
+ params?.onNext?.(newState);
199
+ onData?.(newState);
200
+ }
201
+
202
+ const resetState = (): void => {
203
+ state$.next(nil);
204
+ params?.onNext?.(nil);
205
+ onData?.(nil);
206
+ }
207
+
208
+ const complete = (): void => {
209
+ onComplete?.();
210
+ state$.complete();
211
+ }
212
+
213
+ const update = (): Observable<T> => {
214
+ if (updateRecourse$ instanceof Observable) {
215
+ _updateProceeding = true;
216
+
217
+ return requestUpdateFromObservable(updateRecourse$);
218
+ } else if(updateRecourse$ instanceof Promise) {
219
+ _updateProceeding = true;
220
+
221
+ return requestUpdateFromObservable(from(updateRecourse$))
222
+ } else if (updateRecourse$ instanceof Function) {
223
+ _updateProceeding = true;
224
+ const result = updateRecourse$();
225
+
226
+ if (result instanceof Promise) {
227
+ return requestUpdateFromObservable(from(result));
228
+ } else if (result instanceof Observable) {
229
+ return requestUpdateFromObservable(result);
230
+ }
231
+
232
+ state$.next(result);
233
+ onData?.(result);
234
+
235
+ return nonEmptyStateRef$;
236
+ } else {
237
+ state$.next(updateRecourse$);
238
+ onData?.(updateRecourse$);
239
+
240
+ return nonEmptyStateRef$;
241
+ }
242
+ }
243
+
244
+ const getValue = (): T => {
245
+ if(state$.getValue() !== EMPTY_SYMBOL) {
246
+ return state$.getValue() as T
247
+ }
248
+ // default value is required in this case
249
+ return params?.defaultValue as T
250
+ }
251
+
252
+ const patchState = () => {
253
+ if(patchedState !== null) {
254
+ void Promise.resolve(() => {
255
+ state$.next(patchedState!);
256
+ patchedState = null
257
+ })
258
+ }
259
+ }
260
+
261
+ const requestUpdateFromObservable = (updateRecourse: Observable<T>): Observable<T> => {
262
+ return updateRecourse.pipe(
263
+ tap({
264
+ next: (value) => {
265
+ next(value);
266
+ _updateProceeding = false;
267
+ },
268
+ error: () => {
269
+ _updateProceeding = false
270
+ },
271
+ }),
272
+ switchMap(() => nonEmptyStateRef$)
273
+ );
274
+ }
275
+
276
+ if(params?.constant) {
277
+ return {
278
+ name, state$,
279
+ nil,
280
+ rc: Object.assign(getConstantObservable(), {
281
+ getObservable: getConstantObservable,
282
+ isReactiveCacheObservable,
283
+ })
284
+ }
285
+ }
286
+
287
+ if(params?.allowManualUpdate === false) {
288
+ if(params?.valueReachable) {
289
+ return {
290
+ name, state$,
291
+ nil,
292
+ rc: Object.assign(getObservable(), {
293
+ getObservable,
294
+ update,
295
+ complete,
296
+ resetState,
297
+ getValue,
298
+ isReactiveCacheObservable,
299
+ })
300
+ }
301
+ } else {
302
+ return {
303
+ name, state$,
304
+ nil,
305
+ rc: Object.assign(getObservable(), {
306
+ getObservable,
307
+ update,
308
+ complete,
309
+ resetState,
310
+ isReactiveCacheObservable,
311
+ })
312
+ }
313
+ }
314
+ }
315
+
316
+ if(params?.valueReachable) {
317
+ return {
318
+ name, state$,
319
+ nil,
320
+ rc: Object.assign(getObservable(), {
321
+ getObservable,
322
+ next,
323
+ resetState,
324
+ update,
325
+ complete,
326
+ getValue,
327
+ isReactiveCacheObservable,
328
+ })
329
+ };
330
+ } else {
331
+ return {
332
+ name, state$,
333
+ nil,
334
+ rc: Object.assign(getObservable(), {
335
+ getObservable,
336
+ next,
337
+ resetState,
338
+ update,
339
+ complete,
340
+ isReactiveCacheObservable,
341
+ })
342
+ }
343
+ }
341
344
  }
package/.idea/material_theme_project_new.xml DELETED
@@ -1,13 +0,0 @@
1
- <?xml version="1.0" encoding="UTF-8"?>
2
- <project version="4">
3
- <component name="MaterialThemeProjectNewConfig">
4
- <option name="metadata">
5
- <MTProjectMetadataState>
6
- <option name="migrated" value="true" />
7
- <option name="pristineConfig" value="false" />
8
- <option name="userId" value="-4b6355e5:18c908035a5:-8000" />
9
- <option name="version" value="8.13.2" />
10
- </MTProjectMetadataState>
11
- </option>
12
- </component>
13
- </project>
package/.idea/modules.xml DELETED
@@ -1,8 +0,0 @@
1
- <?xml version="1.0" encoding="UTF-8"?>
2
- <project version="4">
3
- <component name="ProjectModuleManager">
4
- <modules>
5
- <module fileurl="file://$PROJECT_DIR$/.idea/reactive-cache.iml" filepath="$PROJECT_DIR$/.idea/reactive-cache.iml" />
6
- </modules>
7
- </component>
8
- </project>
package/.idea/reactive-cache.iml DELETED
@@ -1,13 +0,0 @@
1
- <?xml version="1.0" encoding="UTF-8"?>
2
- <module type="WEB_MODULE" version="4">
3
- <component name="NewModuleRootManager">
4
- <content url="file://$MODULE_DIR$">
5
- <excludeFolder url="file://$MODULE_DIR$/.tmp" />
6
- <excludeFolder url="file://$MODULE_DIR$/temp" />
7
- <excludeFolder url="file://$MODULE_DIR$/tmp" />
8
- <excludeFolder url="file://$MODULE_DIR$/dist" />
9
- </content>
10
- <orderEntry type="inheritedJdk" />
11
- <orderEntry type="sourceFolder" forTests="false" />
12
- </component>
13
- </module>
package/.idea/vcs.xml DELETED
@@ -1,6 +0,0 @@
1
- <?xml version="1.0" encoding="UTF-8"?>
2
- <project version="4">
3
- <component name="VcsDirectoryMappings">
4
- <mapping directory="$PROJECT_DIR$" vcs="Git" />
5
- </component>
6
- </project>