@oimdb/react 2.0.1 → 2.1.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.
- package/dist/index.cjs +282 -60
- package/dist/index.d.cts +15 -2
- package/dist/index.d.ts +15 -2
- package/dist/index.js +229 -19
- package/package.json +1 -1
package/dist/index.cjs
CHANGED
|
@@ -25,33 +25,243 @@ __export(index_exports, {
|
|
|
25
25
|
createOIMCollectionsContext: () => createOIMCollectionsContext,
|
|
26
26
|
useOIMCollectionsContext: () => useOIMCollectionsContext,
|
|
27
27
|
useSelectEntitiesByIndexKeyArrayBased: () => useSelectEntitiesByIndexKeyArrayBased,
|
|
28
|
+
useSelectEntitiesByIndexKeyArrayBasedFast: () => useSelectEntitiesByIndexKeyArrayBasedFast,
|
|
28
29
|
useSelectEntitiesByIndexKeySetBased: () => useSelectEntitiesByIndexKeySetBased,
|
|
30
|
+
useSelectEntitiesByIndexKeySetBasedFast: () => useSelectEntitiesByIndexKeySetBasedFast,
|
|
29
31
|
useSelectEntitiesByIndexKeysArrayBased: () => useSelectEntitiesByIndexKeysArrayBased,
|
|
32
|
+
useSelectEntitiesByIndexKeysArrayBasedFast: () => useSelectEntitiesByIndexKeysArrayBasedFast,
|
|
30
33
|
useSelectEntitiesByIndexKeysSetBased: () => useSelectEntitiesByIndexKeysSetBased,
|
|
34
|
+
useSelectEntitiesByIndexKeysSetBasedFast: () => useSelectEntitiesByIndexKeysSetBasedFast,
|
|
31
35
|
useSelectEntitiesByPks: () => useSelectEntitiesByPks,
|
|
36
|
+
useSelectEntitiesByPksFast: () => useSelectEntitiesByPksFast,
|
|
32
37
|
useSelectEntityByPk: () => useSelectEntityByPk,
|
|
38
|
+
useSelectEntityByPkFast: () => useSelectEntityByPkFast,
|
|
33
39
|
useSelectPksByIndexKeyArrayBased: () => useSelectPksByIndexKeyArrayBased,
|
|
40
|
+
useSelectPksByIndexKeyArrayBasedFast: () => useSelectPksByIndexKeyArrayBasedFast,
|
|
34
41
|
useSelectPksByIndexKeySetBased: () => useSelectPksByIndexKeySetBased,
|
|
42
|
+
useSelectPksByIndexKeySetBasedFast: () => useSelectPksByIndexKeySetBasedFast,
|
|
35
43
|
useSelectPksByIndexKeysArrayBased: () => useSelectPksByIndexKeysArrayBased,
|
|
44
|
+
useSelectPksByIndexKeysArrayBasedFast: () => useSelectPksByIndexKeysArrayBasedFast,
|
|
36
45
|
useSelectPksByIndexKeysSetBased: () => useSelectPksByIndexKeysSetBased,
|
|
46
|
+
useSelectPksByIndexKeysSetBasedFast: () => useSelectPksByIndexKeysSetBasedFast,
|
|
37
47
|
useSelectValueByObjectKey: () => useSelectValueByObjectKey,
|
|
38
|
-
|
|
48
|
+
useSelectValueByObjectKeyFast: () => useSelectValueByObjectKeyFast,
|
|
49
|
+
useSelectValuesByObjectKeys: () => useSelectValuesByObjectKeys,
|
|
50
|
+
useSelectValuesByObjectKeysFast: () => useSelectValuesByObjectKeysFast
|
|
39
51
|
});
|
|
40
52
|
module.exports = __toCommonJS(index_exports);
|
|
41
53
|
|
|
42
54
|
// src/hooks/index.ts
|
|
43
|
-
var import_react = require("react");
|
|
44
55
|
var import_react2 = require("react");
|
|
56
|
+
var import_react3 = require("react");
|
|
57
|
+
|
|
58
|
+
// src/hooks/fast.ts
|
|
59
|
+
var import_react = require("react");
|
|
60
|
+
var useIsomorphicLayoutEffect = typeof window !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect;
|
|
61
|
+
function useForceUpdate() {
|
|
62
|
+
const [, force] = (0, import_react.useReducer)((c) => c + 1 | 0, 0);
|
|
63
|
+
return force;
|
|
64
|
+
}
|
|
65
|
+
function objectIsEqual(a, b) {
|
|
66
|
+
return Object.is(a, b);
|
|
67
|
+
}
|
|
68
|
+
function shallowEqualArray(a, b) {
|
|
69
|
+
if (a === b) return true;
|
|
70
|
+
if (a.length !== b.length) return false;
|
|
71
|
+
for (let i = 0; i < a.length; i++) {
|
|
72
|
+
if (!Object.is(a[i], b[i])) return false;
|
|
73
|
+
}
|
|
74
|
+
return true;
|
|
75
|
+
}
|
|
76
|
+
function setEqual(a, b) {
|
|
77
|
+
if (a === b) return true;
|
|
78
|
+
if (a.size !== b.size) return false;
|
|
79
|
+
for (const value of a) {
|
|
80
|
+
if (!b.has(value)) return false;
|
|
81
|
+
}
|
|
82
|
+
return true;
|
|
83
|
+
}
|
|
84
|
+
function useStableArray(input) {
|
|
85
|
+
const ref = (0, import_react.useRef)(input);
|
|
86
|
+
if (!shallowEqualArray(ref.current, input)) {
|
|
87
|
+
ref.current = input;
|
|
88
|
+
}
|
|
89
|
+
return ref.current;
|
|
90
|
+
}
|
|
91
|
+
function useFastReactiveValue(read, subscribe, isEqual, deps) {
|
|
92
|
+
const force = useForceUpdate();
|
|
93
|
+
const cache = (0, import_react.useRef)(null);
|
|
94
|
+
const incoming = read();
|
|
95
|
+
if (cache.current === null || !isEqual(cache.current.value, incoming)) {
|
|
96
|
+
cache.current = { value: incoming };
|
|
97
|
+
}
|
|
98
|
+
const value = cache.current.value;
|
|
99
|
+
useIsomorphicLayoutEffect(() => {
|
|
100
|
+
let active = true;
|
|
101
|
+
const onChange = () => {
|
|
102
|
+
if (!active) return;
|
|
103
|
+
const next = read();
|
|
104
|
+
if (cache.current !== null && isEqual(cache.current.value, next)) {
|
|
105
|
+
return;
|
|
106
|
+
}
|
|
107
|
+
cache.current = { value: next };
|
|
108
|
+
force();
|
|
109
|
+
};
|
|
110
|
+
const unsubscribe = subscribe(onChange);
|
|
111
|
+
const latest = read();
|
|
112
|
+
if (cache.current === null || !isEqual(cache.current.value, latest)) {
|
|
113
|
+
cache.current = { value: latest };
|
|
114
|
+
force();
|
|
115
|
+
}
|
|
116
|
+
return () => {
|
|
117
|
+
active = false;
|
|
118
|
+
unsubscribe();
|
|
119
|
+
};
|
|
120
|
+
}, deps);
|
|
121
|
+
return value;
|
|
122
|
+
}
|
|
123
|
+
var useSelectEntityByPkFast = (reactiveCollection, pk) => useFastReactiveValue(
|
|
124
|
+
() => reactiveCollection.getOneByPk(pk),
|
|
125
|
+
(onChange) => reactiveCollection.subscribeOnKey(pk, onChange),
|
|
126
|
+
objectIsEqual,
|
|
127
|
+
[reactiveCollection, pk]
|
|
128
|
+
);
|
|
129
|
+
var useSelectEntitiesByPksFast = (reactiveCollection, pks) => {
|
|
130
|
+
const stablePks = useStableArray(pks);
|
|
131
|
+
return useFastReactiveValue(
|
|
132
|
+
() => stablePks.map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
133
|
+
(onChange) => reactiveCollection.subscribeOnKeys(stablePks, onChange),
|
|
134
|
+
shallowEqualArray,
|
|
135
|
+
[reactiveCollection, stablePks]
|
|
136
|
+
);
|
|
137
|
+
};
|
|
138
|
+
var useSelectValueByObjectKeyFast = (reactiveObject, key) => useFastReactiveValue(
|
|
139
|
+
() => reactiveObject.get(key),
|
|
140
|
+
(onChange) => reactiveObject.subscribeOnKey(key, onChange),
|
|
141
|
+
objectIsEqual,
|
|
142
|
+
[reactiveObject, key]
|
|
143
|
+
);
|
|
144
|
+
var useSelectValuesByObjectKeysFast = (reactiveObject, keys) => {
|
|
145
|
+
const stableKeys = useStableArray(keys);
|
|
146
|
+
return useFastReactiveValue(
|
|
147
|
+
() => stableKeys.map((key) => reactiveObject.get(key)),
|
|
148
|
+
(onChange) => reactiveObject.subscribeOnKeys(stableKeys, onChange),
|
|
149
|
+
shallowEqualArray,
|
|
150
|
+
[reactiveObject, stableKeys]
|
|
151
|
+
);
|
|
152
|
+
};
|
|
153
|
+
var useSelectPksByIndexKeySetBasedFast = (reactiveIndex, key) => useFastReactiveValue(
|
|
154
|
+
() => reactiveIndex.getPksByKey(key),
|
|
155
|
+
(onChange) => reactiveIndex.subscribeOnKey(key, onChange),
|
|
156
|
+
setEqual,
|
|
157
|
+
[reactiveIndex, key]
|
|
158
|
+
);
|
|
159
|
+
var useSelectPksByIndexKeyArrayBasedFast = (reactiveIndex, key) => useFastReactiveValue(
|
|
160
|
+
() => reactiveIndex.getPksByKey(key),
|
|
161
|
+
(onChange) => reactiveIndex.subscribeOnKey(key, onChange),
|
|
162
|
+
shallowEqualArray,
|
|
163
|
+
[reactiveIndex, key]
|
|
164
|
+
);
|
|
165
|
+
var useSelectPksByIndexKeysSetBasedFast = (reactiveIndex, keys) => {
|
|
166
|
+
const stableKeys = useStableArray(keys);
|
|
167
|
+
return useFastReactiveValue(
|
|
168
|
+
() => stableKeys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat(),
|
|
169
|
+
(onChange) => reactiveIndex.subscribeOnKeys(stableKeys, onChange),
|
|
170
|
+
shallowEqualArray,
|
|
171
|
+
[reactiveIndex, stableKeys]
|
|
172
|
+
);
|
|
173
|
+
};
|
|
174
|
+
var useSelectPksByIndexKeysArrayBasedFast = (reactiveIndex, keys) => {
|
|
175
|
+
const stableKeys = useStableArray(keys);
|
|
176
|
+
return useFastReactiveValue(
|
|
177
|
+
() => stableKeys.map((key) => reactiveIndex.getPksByKey(key)).flat(),
|
|
178
|
+
(onChange) => reactiveIndex.subscribeOnKeys(stableKeys, onChange),
|
|
179
|
+
shallowEqualArray,
|
|
180
|
+
[reactiveIndex, stableKeys]
|
|
181
|
+
);
|
|
182
|
+
};
|
|
183
|
+
function subscribeIndexAndPks(subscribeIndex, subscribeCollection, readPks, onChange) {
|
|
184
|
+
let unsubscribeCollection = subscribeCollection(readPks(), onChange);
|
|
185
|
+
const unsubscribeIndex = subscribeIndex(() => {
|
|
186
|
+
unsubscribeCollection();
|
|
187
|
+
unsubscribeCollection = subscribeCollection(readPks(), onChange);
|
|
188
|
+
onChange();
|
|
189
|
+
});
|
|
190
|
+
return () => {
|
|
191
|
+
unsubscribeIndex();
|
|
192
|
+
unsubscribeCollection();
|
|
193
|
+
};
|
|
194
|
+
}
|
|
195
|
+
var useSelectEntitiesByIndexKeySetBasedFast = (reactiveCollection, reactiveIndex, key) => {
|
|
196
|
+
const readPks = () => Array.from(reactiveIndex.getPksByKey(key));
|
|
197
|
+
return useFastReactiveValue(
|
|
198
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
199
|
+
(onChange) => subscribeIndexAndPks(
|
|
200
|
+
(cb) => reactiveIndex.subscribeOnKey(key, cb),
|
|
201
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
202
|
+
readPks,
|
|
203
|
+
onChange
|
|
204
|
+
),
|
|
205
|
+
shallowEqualArray,
|
|
206
|
+
[reactiveCollection, reactiveIndex, key]
|
|
207
|
+
);
|
|
208
|
+
};
|
|
209
|
+
var useSelectEntitiesByIndexKeyArrayBasedFast = (reactiveCollection, reactiveIndex, key) => {
|
|
210
|
+
const readPks = () => reactiveIndex.getPksByKey(key);
|
|
211
|
+
return useFastReactiveValue(
|
|
212
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
213
|
+
(onChange) => subscribeIndexAndPks(
|
|
214
|
+
(cb) => reactiveIndex.subscribeOnKey(key, cb),
|
|
215
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
216
|
+
readPks,
|
|
217
|
+
onChange
|
|
218
|
+
),
|
|
219
|
+
shallowEqualArray,
|
|
220
|
+
[reactiveCollection, reactiveIndex, key]
|
|
221
|
+
);
|
|
222
|
+
};
|
|
223
|
+
var useSelectEntitiesByIndexKeysSetBasedFast = (reactiveCollection, reactiveIndex, keys) => {
|
|
224
|
+
const stableKeys = useStableArray(keys);
|
|
225
|
+
const readPks = () => stableKeys.flatMap((key) => Array.from(reactiveIndex.getPksByKey(key)));
|
|
226
|
+
return useFastReactiveValue(
|
|
227
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
228
|
+
(onChange) => subscribeIndexAndPks(
|
|
229
|
+
(cb) => reactiveIndex.subscribeOnKeys(stableKeys, cb),
|
|
230
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
231
|
+
readPks,
|
|
232
|
+
onChange
|
|
233
|
+
),
|
|
234
|
+
shallowEqualArray,
|
|
235
|
+
[reactiveCollection, reactiveIndex, stableKeys]
|
|
236
|
+
);
|
|
237
|
+
};
|
|
238
|
+
var useSelectEntitiesByIndexKeysArrayBasedFast = (reactiveCollection, reactiveIndex, keys) => {
|
|
239
|
+
const stableKeys = useStableArray(keys);
|
|
240
|
+
const readPks = () => stableKeys.flatMap((key) => reactiveIndex.getPksByKey(key));
|
|
241
|
+
return useFastReactiveValue(
|
|
242
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
243
|
+
(onChange) => subscribeIndexAndPks(
|
|
244
|
+
(cb) => reactiveIndex.subscribeOnKeys(stableKeys, cb),
|
|
245
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
246
|
+
readPks,
|
|
247
|
+
onChange
|
|
248
|
+
),
|
|
249
|
+
shallowEqualArray,
|
|
250
|
+
[reactiveCollection, reactiveIndex, stableKeys]
|
|
251
|
+
);
|
|
252
|
+
};
|
|
253
|
+
|
|
254
|
+
// src/hooks/index.ts
|
|
45
255
|
var EMPTY_ARRAY = [];
|
|
46
256
|
var useSelectPksByIndexKeysSetBased = (reactiveIndex, keys) => {
|
|
47
|
-
const prevKeysRef = (0,
|
|
257
|
+
const prevKeysRef = (0, import_react2.useRef)();
|
|
48
258
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
49
259
|
if (!keysAreEqual) {
|
|
50
260
|
prevKeysRef.current = keys;
|
|
51
261
|
}
|
|
52
262
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
53
|
-
const snapshotValueRef = (0,
|
|
54
|
-
const subscribe = (0,
|
|
263
|
+
const snapshotValueRef = (0, import_react2.useRef)();
|
|
264
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
55
265
|
snapshotValueRef.current = stableKeys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat();
|
|
56
266
|
return (onStoreChange) => {
|
|
57
267
|
const updateSnapshot = () => {
|
|
@@ -67,17 +277,17 @@ var useSelectPksByIndexKeysSetBased = (reactiveIndex, keys) => {
|
|
|
67
277
|
};
|
|
68
278
|
};
|
|
69
279
|
}, [reactiveIndex, stableKeys]);
|
|
70
|
-
const getSnapshot = (0,
|
|
280
|
+
const getSnapshot = (0, import_react2.useMemo)(() => {
|
|
71
281
|
return () => {
|
|
72
282
|
return snapshotValueRef.current;
|
|
73
283
|
};
|
|
74
284
|
}, []);
|
|
75
|
-
const snapshot = (0,
|
|
285
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
76
286
|
return snapshot;
|
|
77
287
|
};
|
|
78
288
|
var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
|
|
79
|
-
const snapshotValueRef = (0,
|
|
80
|
-
const subscribe = (0,
|
|
289
|
+
const snapshotValueRef = (0, import_react2.useRef)();
|
|
290
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
81
291
|
snapshotValueRef.current = reactiveIndex.getPksByKey(key);
|
|
82
292
|
return (onStoreChange) => {
|
|
83
293
|
const updateSnapshot = () => {
|
|
@@ -87,23 +297,23 @@ var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
|
|
|
87
297
|
return reactiveIndex.subscribeOnKey(key, updateSnapshot);
|
|
88
298
|
};
|
|
89
299
|
}, [key, reactiveIndex]);
|
|
90
|
-
const getSnapshot = (0,
|
|
300
|
+
const getSnapshot = (0, import_react2.useMemo)(() => {
|
|
91
301
|
return () => {
|
|
92
302
|
return snapshotValueRef.current;
|
|
93
303
|
};
|
|
94
304
|
}, []);
|
|
95
|
-
const snapshot = (0,
|
|
305
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
96
306
|
return snapshot;
|
|
97
307
|
};
|
|
98
308
|
var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
|
|
99
|
-
const prevKeysRef = (0,
|
|
309
|
+
const prevKeysRef = (0, import_react2.useRef)();
|
|
100
310
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
101
311
|
if (!keysAreEqual) {
|
|
102
312
|
prevKeysRef.current = keys;
|
|
103
313
|
}
|
|
104
314
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
105
|
-
const snapshotValueRef = (0,
|
|
106
|
-
const subscribe = (0,
|
|
315
|
+
const snapshotValueRef = (0, import_react2.useRef)();
|
|
316
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
107
317
|
snapshotValueRef.current = stableKeys.map((key) => reactiveIndex.getPksByKey(key)).flat();
|
|
108
318
|
return (onStoreChange) => {
|
|
109
319
|
const updateSnapshot = () => {
|
|
@@ -119,22 +329,22 @@ var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
|
|
|
119
329
|
};
|
|
120
330
|
};
|
|
121
331
|
}, [reactiveIndex, stableKeys]);
|
|
122
|
-
const getSnapshot = (0,
|
|
332
|
+
const getSnapshot = (0, import_react2.useMemo)(() => {
|
|
123
333
|
return () => {
|
|
124
334
|
return snapshotValueRef.current;
|
|
125
335
|
};
|
|
126
336
|
}, []);
|
|
127
|
-
const snapshot = (0,
|
|
337
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
128
338
|
return snapshot;
|
|
129
339
|
};
|
|
130
340
|
var useSelectPksByIndexKeyArrayBased = (reactiveIndex, key) => {
|
|
131
|
-
const prevKeyRef = (0,
|
|
341
|
+
const prevKeyRef = (0, import_react2.useRef)();
|
|
132
342
|
const keyAreEqual = prevKeyRef.current === key;
|
|
133
343
|
if (!keyAreEqual) {
|
|
134
344
|
prevKeyRef.current = key;
|
|
135
345
|
}
|
|
136
|
-
const snapshotValueRef = (0,
|
|
137
|
-
const subscribe = (0,
|
|
346
|
+
const snapshotValueRef = (0, import_react2.useRef)();
|
|
347
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
138
348
|
snapshotValueRef.current = reactiveIndex.getPksByKey(key);
|
|
139
349
|
return (onStoreChange) => {
|
|
140
350
|
const prevKey = prevKeyRef.current;
|
|
@@ -155,49 +365,49 @@ var useSelectPksByIndexKeyArrayBased = (reactiveIndex, key) => {
|
|
|
155
365
|
};
|
|
156
366
|
};
|
|
157
367
|
}, [key, reactiveIndex]);
|
|
158
|
-
const getSnapshot = (0,
|
|
368
|
+
const getSnapshot = (0, import_react2.useMemo)(() => {
|
|
159
369
|
return () => {
|
|
160
370
|
return snapshotValueRef.current;
|
|
161
371
|
};
|
|
162
372
|
}, []);
|
|
163
|
-
const snapshot = (0,
|
|
373
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
164
374
|
return snapshot;
|
|
165
375
|
};
|
|
166
376
|
var useSelectEntityByPk = (reactiveCollection, pk) => {
|
|
167
|
-
const getSnapshot = (0,
|
|
377
|
+
const getSnapshot = (0, import_react2.useMemo)(
|
|
168
378
|
() => () => reactiveCollection.getOneByPk(pk),
|
|
169
379
|
[pk, reactiveCollection]
|
|
170
380
|
);
|
|
171
|
-
const subscribe = (0,
|
|
381
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
172
382
|
return (onStoreChange) => {
|
|
173
383
|
return reactiveCollection.subscribeOnKey(pk, onStoreChange);
|
|
174
384
|
};
|
|
175
385
|
}, [pk, reactiveCollection]);
|
|
176
|
-
const snapshot = (0,
|
|
386
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
177
387
|
return snapshot;
|
|
178
388
|
};
|
|
179
389
|
var useSelectValueByObjectKey = (reactiveObject, key) => {
|
|
180
|
-
const getSnapshot = (0,
|
|
390
|
+
const getSnapshot = (0, import_react2.useMemo)(
|
|
181
391
|
() => () => reactiveObject.get(key),
|
|
182
392
|
[key, reactiveObject]
|
|
183
393
|
);
|
|
184
|
-
const subscribe = (0,
|
|
394
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
185
395
|
return (onStoreChange) => {
|
|
186
396
|
return reactiveObject.subscribeOnKey(key, onStoreChange);
|
|
187
397
|
};
|
|
188
398
|
}, [key, reactiveObject]);
|
|
189
|
-
const snapshot = (0,
|
|
399
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
190
400
|
return snapshot;
|
|
191
401
|
};
|
|
192
402
|
var useSelectValuesByObjectKeys = (reactiveObject, keys) => {
|
|
193
|
-
const prevKeysRef = (0,
|
|
403
|
+
const prevKeysRef = (0, import_react2.useRef)();
|
|
194
404
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
195
405
|
if (!keysAreEqual) {
|
|
196
406
|
prevKeysRef.current = keys;
|
|
197
407
|
}
|
|
198
408
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
199
|
-
const snapshotRef = (0,
|
|
200
|
-
const subscribe = (0,
|
|
409
|
+
const snapshotRef = (0, import_react2.useRef)();
|
|
410
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
201
411
|
snapshotRef.current = stableKeys.map((key) => reactiveObject.get(key));
|
|
202
412
|
return (onStoreChange) => {
|
|
203
413
|
const updateSnapshot = () => {
|
|
@@ -215,12 +425,12 @@ var useSelectValuesByObjectKeys = (reactiveObject, keys) => {
|
|
|
215
425
|
};
|
|
216
426
|
};
|
|
217
427
|
}, [reactiveObject, stableKeys]);
|
|
218
|
-
const getSnapshot = (0,
|
|
428
|
+
const getSnapshot = (0, import_react2.useMemo)(() => {
|
|
219
429
|
return () => {
|
|
220
430
|
return snapshotRef.current;
|
|
221
431
|
};
|
|
222
432
|
}, []);
|
|
223
|
-
const snapshot = (0,
|
|
433
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
224
434
|
return snapshot;
|
|
225
435
|
};
|
|
226
436
|
function arraysEqual(a, b) {
|
|
@@ -232,14 +442,14 @@ function arraysEqual(a, b) {
|
|
|
232
442
|
return true;
|
|
233
443
|
}
|
|
234
444
|
var useSelectEntitiesByPks = (reactiveCollection, pks) => {
|
|
235
|
-
const prevPksRef = (0,
|
|
445
|
+
const prevPksRef = (0, import_react2.useRef)();
|
|
236
446
|
const pksAreEqual = arraysEqual(prevPksRef.current || EMPTY_ARRAY, pks);
|
|
237
447
|
if (!pksAreEqual) {
|
|
238
448
|
prevPksRef.current = pks;
|
|
239
449
|
}
|
|
240
450
|
const stablePks = pksAreEqual ? prevPksRef.current ?? pks : pks;
|
|
241
|
-
const snapshotRef = (0,
|
|
242
|
-
const subscribe = (0,
|
|
451
|
+
const snapshotRef = (0, import_react2.useRef)();
|
|
452
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
243
453
|
snapshotRef.current = stablePks.map(
|
|
244
454
|
(pk) => reactiveCollection.getOneByPk(pk)
|
|
245
455
|
);
|
|
@@ -259,17 +469,17 @@ var useSelectEntitiesByPks = (reactiveCollection, pks) => {
|
|
|
259
469
|
};
|
|
260
470
|
};
|
|
261
471
|
}, [reactiveCollection, stablePks]);
|
|
262
|
-
const getSnapshot = (0,
|
|
472
|
+
const getSnapshot = (0, import_react2.useMemo)(() => {
|
|
263
473
|
return () => {
|
|
264
474
|
return snapshotRef.current;
|
|
265
475
|
};
|
|
266
476
|
}, []);
|
|
267
|
-
const snapshot = (0,
|
|
477
|
+
const snapshot = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
268
478
|
return snapshot;
|
|
269
479
|
};
|
|
270
480
|
var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, key) => {
|
|
271
|
-
const snapshotRef = (0,
|
|
272
|
-
const subscribe = (0,
|
|
481
|
+
const snapshotRef = (0, import_react2.useRef)();
|
|
482
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
273
483
|
const readSnapshot = () => Array.from(
|
|
274
484
|
reactiveIndex.getPksByKey(key),
|
|
275
485
|
(pk) => reactiveCollection.getOneByPk(pk)
|
|
@@ -302,18 +512,18 @@ var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, ke
|
|
|
302
512
|
};
|
|
303
513
|
};
|
|
304
514
|
}, [key, reactiveCollection, reactiveIndex]);
|
|
305
|
-
const getSnapshot = (0,
|
|
306
|
-
return (0,
|
|
515
|
+
const getSnapshot = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
|
|
516
|
+
return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
307
517
|
};
|
|
308
518
|
var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, keys) => {
|
|
309
|
-
const prevKeysRef = (0,
|
|
519
|
+
const prevKeysRef = (0, import_react2.useRef)();
|
|
310
520
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
311
521
|
if (!keysAreEqual) {
|
|
312
522
|
prevKeysRef.current = keys;
|
|
313
523
|
}
|
|
314
524
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
315
|
-
const snapshotRef = (0,
|
|
316
|
-
const subscribe = (0,
|
|
525
|
+
const snapshotRef = (0, import_react2.useRef)();
|
|
526
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
317
527
|
const readPks = () => stableKeys.flatMap(
|
|
318
528
|
(key) => Array.from(reactiveIndex.getPksByKey(key))
|
|
319
529
|
);
|
|
@@ -348,12 +558,12 @@ var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, k
|
|
|
348
558
|
};
|
|
349
559
|
};
|
|
350
560
|
}, [reactiveCollection, reactiveIndex, stableKeys]);
|
|
351
|
-
const getSnapshot = (0,
|
|
352
|
-
return (0,
|
|
561
|
+
const getSnapshot = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
|
|
562
|
+
return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
353
563
|
};
|
|
354
564
|
var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex, key) => {
|
|
355
|
-
const snapshotRef = (0,
|
|
356
|
-
const subscribe = (0,
|
|
565
|
+
const snapshotRef = (0, import_react2.useRef)();
|
|
566
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
357
567
|
const readSnapshot = () => reactiveIndex.getPksByKey(key).map((pk) => reactiveCollection.getOneByPk(pk));
|
|
358
568
|
const readPks = () => reactiveIndex.getPksByKey(key);
|
|
359
569
|
snapshotRef.current = readSnapshot();
|
|
@@ -383,18 +593,18 @@ var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex,
|
|
|
383
593
|
};
|
|
384
594
|
};
|
|
385
595
|
}, [key, reactiveCollection, reactiveIndex]);
|
|
386
|
-
const getSnapshot = (0,
|
|
387
|
-
return (0,
|
|
596
|
+
const getSnapshot = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
|
|
597
|
+
return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
388
598
|
};
|
|
389
599
|
var useSelectEntitiesByIndexKeysArrayBased = (reactiveCollection, reactiveIndex, keys) => {
|
|
390
|
-
const prevKeysRef = (0,
|
|
600
|
+
const prevKeysRef = (0, import_react2.useRef)();
|
|
391
601
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
392
602
|
if (!keysAreEqual) {
|
|
393
603
|
prevKeysRef.current = keys;
|
|
394
604
|
}
|
|
395
605
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
396
|
-
const snapshotRef = (0,
|
|
397
|
-
const subscribe = (0,
|
|
606
|
+
const snapshotRef = (0, import_react2.useRef)();
|
|
607
|
+
const subscribe = (0, import_react2.useMemo)(() => {
|
|
398
608
|
const readPks = () => stableKeys.flatMap((key) => reactiveIndex.getPksByKey(key));
|
|
399
609
|
const readSnapshot = () => readPks().map((pk) => reactiveCollection.getOneByPk(pk));
|
|
400
610
|
snapshotRef.current = readSnapshot();
|
|
@@ -427,18 +637,18 @@ var useSelectEntitiesByIndexKeysArrayBased = (reactiveCollection, reactiveIndex,
|
|
|
427
637
|
};
|
|
428
638
|
};
|
|
429
639
|
}, [reactiveCollection, reactiveIndex, stableKeys]);
|
|
430
|
-
const getSnapshot = (0,
|
|
431
|
-
return (0,
|
|
640
|
+
const getSnapshot = (0, import_react2.useMemo)(() => () => snapshotRef.current, []);
|
|
641
|
+
return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
|
|
432
642
|
};
|
|
433
643
|
|
|
434
644
|
// src/context/index.tsx
|
|
435
|
-
var
|
|
645
|
+
var import_react4 = require("react");
|
|
436
646
|
var import_jsx_runtime = require("react/jsx-runtime");
|
|
437
|
-
var OIMCollectionsContext = (0,
|
|
647
|
+
var OIMCollectionsContext = (0, import_react4.createContext)(
|
|
438
648
|
{}
|
|
439
649
|
);
|
|
440
650
|
function createOIMCollectionsContext() {
|
|
441
|
-
return (0,
|
|
651
|
+
return (0, import_react4.createContext)({});
|
|
442
652
|
}
|
|
443
653
|
function OIMCollectionsProvider({ collections, children, context }) {
|
|
444
654
|
const ContextToUse = context || OIMCollectionsContext;
|
|
@@ -446,7 +656,7 @@ function OIMCollectionsProvider({ collections, children, context }) {
|
|
|
446
656
|
}
|
|
447
657
|
function useOIMCollectionsContext(context) {
|
|
448
658
|
const contextToUse = context || OIMCollectionsContext;
|
|
449
|
-
const collections = (0,
|
|
659
|
+
const collections = (0, import_react4.useContext)(contextToUse);
|
|
450
660
|
if (!collections || Object.keys(collections).length === 0) {
|
|
451
661
|
throw new Error(
|
|
452
662
|
"useOIMCollectionsContext must be used within an OIMCollectionsProvider"
|
|
@@ -461,15 +671,27 @@ function useOIMCollectionsContext(context) {
|
|
|
461
671
|
createOIMCollectionsContext,
|
|
462
672
|
useOIMCollectionsContext,
|
|
463
673
|
useSelectEntitiesByIndexKeyArrayBased,
|
|
674
|
+
useSelectEntitiesByIndexKeyArrayBasedFast,
|
|
464
675
|
useSelectEntitiesByIndexKeySetBased,
|
|
676
|
+
useSelectEntitiesByIndexKeySetBasedFast,
|
|
465
677
|
useSelectEntitiesByIndexKeysArrayBased,
|
|
678
|
+
useSelectEntitiesByIndexKeysArrayBasedFast,
|
|
466
679
|
useSelectEntitiesByIndexKeysSetBased,
|
|
680
|
+
useSelectEntitiesByIndexKeysSetBasedFast,
|
|
467
681
|
useSelectEntitiesByPks,
|
|
682
|
+
useSelectEntitiesByPksFast,
|
|
468
683
|
useSelectEntityByPk,
|
|
684
|
+
useSelectEntityByPkFast,
|
|
469
685
|
useSelectPksByIndexKeyArrayBased,
|
|
686
|
+
useSelectPksByIndexKeyArrayBasedFast,
|
|
470
687
|
useSelectPksByIndexKeySetBased,
|
|
688
|
+
useSelectPksByIndexKeySetBasedFast,
|
|
471
689
|
useSelectPksByIndexKeysArrayBased,
|
|
690
|
+
useSelectPksByIndexKeysArrayBasedFast,
|
|
472
691
|
useSelectPksByIndexKeysSetBased,
|
|
692
|
+
useSelectPksByIndexKeysSetBasedFast,
|
|
473
693
|
useSelectValueByObjectKey,
|
|
474
|
-
|
|
694
|
+
useSelectValueByObjectKeyFast,
|
|
695
|
+
useSelectValuesByObjectKeys,
|
|
696
|
+
useSelectValuesByObjectKeysFast
|
|
475
697
|
});
|
package/dist/index.d.cts
CHANGED
|
@@ -1,8 +1,21 @@
|
|
|
1
|
-
import { TOIMPk, OIMIndexSetBased, OIMReactiveIndexSetBased, OIMIndexArrayBased, OIMReactiveIndexArrayBased
|
|
1
|
+
import { TOIMPk, OIMReactiveCollection, OIMReactiveObject, OIMIndexSetBased, OIMReactiveIndexSetBased, OIMIndexArrayBased, OIMReactiveIndexArrayBased } from '@oimdb/core';
|
|
2
2
|
import * as react_jsx_runtime from 'react/jsx-runtime';
|
|
3
3
|
import * as React from 'react';
|
|
4
4
|
import { ReactNode } from 'react';
|
|
5
5
|
|
|
6
|
+
declare const useSelectEntityByPkFast: <TEntity extends object, TPk extends TOIMPk>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, pk: TPk) => TEntity | undefined;
|
|
7
|
+
declare const useSelectEntitiesByPksFast: <TEntity extends object, TPk extends TOIMPk>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]) => readonly (TEntity | undefined)[];
|
|
8
|
+
declare const useSelectValueByObjectKeyFast: <TKey extends string, TValue>(reactiveObject: OIMReactiveObject<TKey, TValue>, key: TKey) => TValue | undefined;
|
|
9
|
+
declare const useSelectValuesByObjectKeysFast: <TKey extends string, TValue>(reactiveObject: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]) => readonly (TValue | undefined)[];
|
|
10
|
+
declare const useSelectPksByIndexKeySetBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey) => ReadonlySet<TPk>;
|
|
11
|
+
declare const useSelectPksByIndexKeyArrayBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey) => readonly TPk[];
|
|
12
|
+
declare const useSelectPksByIndexKeysSetBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly TPk[];
|
|
13
|
+
declare const useSelectPksByIndexKeysArrayBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly TPk[];
|
|
14
|
+
declare const useSelectEntitiesByIndexKeySetBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey) => readonly (TEntity | undefined)[];
|
|
15
|
+
declare const useSelectEntitiesByIndexKeyArrayBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey) => readonly (TEntity | undefined)[];
|
|
16
|
+
declare const useSelectEntitiesByIndexKeysSetBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly (TEntity | undefined)[];
|
|
17
|
+
declare const useSelectEntitiesByIndexKeysArrayBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly (TEntity | undefined)[];
|
|
18
|
+
|
|
6
19
|
declare const useSelectPksByIndexKeysSetBased: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => TPk[] | undefined;
|
|
7
20
|
declare const useSelectPksByIndexKeySetBased: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey) => Set<TPk> | undefined;
|
|
8
21
|
declare const useSelectPksByIndexKeysArrayBased: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => TPk[] | undefined;
|
|
@@ -28,4 +41,4 @@ interface OIMCollectionsProviderProps<T extends CollectionsDictionary = Collecti
|
|
|
28
41
|
declare function OIMCollectionsProvider<T extends CollectionsDictionary = CollectionsDictionary>({ collections, children, context }: OIMCollectionsProviderProps<T>): react_jsx_runtime.JSX.Element;
|
|
29
42
|
declare function useOIMCollectionsContext<T extends CollectionsDictionary = CollectionsDictionary>(context?: React.Context<OIMContextValue<T>>): T;
|
|
30
43
|
|
|
31
|
-
export { type CollectionsDictionary, OIMCollectionsContext, OIMCollectionsProvider, type OIMCollectionsProviderProps, type OIMContextValue, createOIMCollectionsContext, useOIMCollectionsContext, useSelectEntitiesByIndexKeyArrayBased, useSelectEntitiesByIndexKeySetBased, useSelectEntitiesByIndexKeysArrayBased, useSelectEntitiesByIndexKeysSetBased, useSelectEntitiesByPks, useSelectEntityByPk, useSelectPksByIndexKeyArrayBased, useSelectPksByIndexKeySetBased, useSelectPksByIndexKeysArrayBased, useSelectPksByIndexKeysSetBased, useSelectValueByObjectKey, useSelectValuesByObjectKeys };
|
|
44
|
+
export { type CollectionsDictionary, OIMCollectionsContext, OIMCollectionsProvider, type OIMCollectionsProviderProps, type OIMContextValue, createOIMCollectionsContext, useOIMCollectionsContext, useSelectEntitiesByIndexKeyArrayBased, useSelectEntitiesByIndexKeyArrayBasedFast, useSelectEntitiesByIndexKeySetBased, useSelectEntitiesByIndexKeySetBasedFast, useSelectEntitiesByIndexKeysArrayBased, useSelectEntitiesByIndexKeysArrayBasedFast, useSelectEntitiesByIndexKeysSetBased, useSelectEntitiesByIndexKeysSetBasedFast, useSelectEntitiesByPks, useSelectEntitiesByPksFast, useSelectEntityByPk, useSelectEntityByPkFast, useSelectPksByIndexKeyArrayBased, useSelectPksByIndexKeyArrayBasedFast, useSelectPksByIndexKeySetBased, useSelectPksByIndexKeySetBasedFast, useSelectPksByIndexKeysArrayBased, useSelectPksByIndexKeysArrayBasedFast, useSelectPksByIndexKeysSetBased, useSelectPksByIndexKeysSetBasedFast, useSelectValueByObjectKey, useSelectValueByObjectKeyFast, useSelectValuesByObjectKeys, useSelectValuesByObjectKeysFast };
|
package/dist/index.d.ts
CHANGED
|
@@ -1,8 +1,21 @@
|
|
|
1
|
-
import { TOIMPk, OIMIndexSetBased, OIMReactiveIndexSetBased, OIMIndexArrayBased, OIMReactiveIndexArrayBased
|
|
1
|
+
import { TOIMPk, OIMReactiveCollection, OIMReactiveObject, OIMIndexSetBased, OIMReactiveIndexSetBased, OIMIndexArrayBased, OIMReactiveIndexArrayBased } from '@oimdb/core';
|
|
2
2
|
import * as react_jsx_runtime from 'react/jsx-runtime';
|
|
3
3
|
import * as React from 'react';
|
|
4
4
|
import { ReactNode } from 'react';
|
|
5
5
|
|
|
6
|
+
declare const useSelectEntityByPkFast: <TEntity extends object, TPk extends TOIMPk>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, pk: TPk) => TEntity | undefined;
|
|
7
|
+
declare const useSelectEntitiesByPksFast: <TEntity extends object, TPk extends TOIMPk>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, pks: readonly TPk[]) => readonly (TEntity | undefined)[];
|
|
8
|
+
declare const useSelectValueByObjectKeyFast: <TKey extends string, TValue>(reactiveObject: OIMReactiveObject<TKey, TValue>, key: TKey) => TValue | undefined;
|
|
9
|
+
declare const useSelectValuesByObjectKeysFast: <TKey extends string, TValue>(reactiveObject: OIMReactiveObject<TKey, TValue>, keys: readonly TKey[]) => readonly (TValue | undefined)[];
|
|
10
|
+
declare const useSelectPksByIndexKeySetBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey) => ReadonlySet<TPk>;
|
|
11
|
+
declare const useSelectPksByIndexKeyArrayBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey) => readonly TPk[];
|
|
12
|
+
declare const useSelectPksByIndexKeysSetBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly TPk[];
|
|
13
|
+
declare const useSelectPksByIndexKeysArrayBasedFast: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly TPk[];
|
|
14
|
+
declare const useSelectEntitiesByIndexKeySetBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey) => readonly (TEntity | undefined)[];
|
|
15
|
+
declare const useSelectEntitiesByIndexKeyArrayBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, key: TKey) => readonly (TEntity | undefined)[];
|
|
16
|
+
declare const useSelectEntitiesByIndexKeysSetBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly (TEntity | undefined)[];
|
|
17
|
+
declare const useSelectEntitiesByIndexKeysArrayBasedFast: <TEntity extends object, TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveCollection: OIMReactiveCollection<TEntity, TPk>, reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => readonly (TEntity | undefined)[];
|
|
18
|
+
|
|
6
19
|
declare const useSelectPksByIndexKeysSetBased: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => TPk[] | undefined;
|
|
7
20
|
declare const useSelectPksByIndexKeySetBased: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexSetBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexSetBased<TKey, TPk, TIndex>, key: TKey) => Set<TPk> | undefined;
|
|
8
21
|
declare const useSelectPksByIndexKeysArrayBased: <TPk extends TOIMPk, TKey extends TOIMPk, TIndex extends OIMIndexArrayBased<TKey, TPk>>(reactiveIndex: OIMReactiveIndexArrayBased<TKey, TPk, TIndex>, keys: readonly TKey[]) => TPk[] | undefined;
|
|
@@ -28,4 +41,4 @@ interface OIMCollectionsProviderProps<T extends CollectionsDictionary = Collecti
|
|
|
28
41
|
declare function OIMCollectionsProvider<T extends CollectionsDictionary = CollectionsDictionary>({ collections, children, context }: OIMCollectionsProviderProps<T>): react_jsx_runtime.JSX.Element;
|
|
29
42
|
declare function useOIMCollectionsContext<T extends CollectionsDictionary = CollectionsDictionary>(context?: React.Context<OIMContextValue<T>>): T;
|
|
30
43
|
|
|
31
|
-
export { type CollectionsDictionary, OIMCollectionsContext, OIMCollectionsProvider, type OIMCollectionsProviderProps, type OIMContextValue, createOIMCollectionsContext, useOIMCollectionsContext, useSelectEntitiesByIndexKeyArrayBased, useSelectEntitiesByIndexKeySetBased, useSelectEntitiesByIndexKeysArrayBased, useSelectEntitiesByIndexKeysSetBased, useSelectEntitiesByPks, useSelectEntityByPk, useSelectPksByIndexKeyArrayBased, useSelectPksByIndexKeySetBased, useSelectPksByIndexKeysArrayBased, useSelectPksByIndexKeysSetBased, useSelectValueByObjectKey, useSelectValuesByObjectKeys };
|
|
44
|
+
export { type CollectionsDictionary, OIMCollectionsContext, OIMCollectionsProvider, type OIMCollectionsProviderProps, type OIMContextValue, createOIMCollectionsContext, useOIMCollectionsContext, useSelectEntitiesByIndexKeyArrayBased, useSelectEntitiesByIndexKeyArrayBasedFast, useSelectEntitiesByIndexKeySetBased, useSelectEntitiesByIndexKeySetBasedFast, useSelectEntitiesByIndexKeysArrayBased, useSelectEntitiesByIndexKeysArrayBasedFast, useSelectEntitiesByIndexKeysSetBased, useSelectEntitiesByIndexKeysSetBasedFast, useSelectEntitiesByPks, useSelectEntitiesByPksFast, useSelectEntityByPk, useSelectEntityByPkFast, useSelectPksByIndexKeyArrayBased, useSelectPksByIndexKeyArrayBasedFast, useSelectPksByIndexKeySetBased, useSelectPksByIndexKeySetBasedFast, useSelectPksByIndexKeysArrayBased, useSelectPksByIndexKeysArrayBasedFast, useSelectPksByIndexKeysSetBased, useSelectPksByIndexKeysSetBasedFast, useSelectValueByObjectKey, useSelectValueByObjectKeyFast, useSelectValuesByObjectKeys, useSelectValuesByObjectKeysFast };
|
package/dist/index.js
CHANGED
|
@@ -1,15 +1,213 @@
|
|
|
1
1
|
// src/hooks/index.ts
|
|
2
|
-
import { useMemo, useRef } from "react";
|
|
2
|
+
import { useMemo, useRef as useRef2 } from "react";
|
|
3
3
|
import { useSyncExternalStore } from "react";
|
|
4
|
+
|
|
5
|
+
// src/hooks/fast.ts
|
|
6
|
+
import { useEffect, useLayoutEffect, useReducer, useRef } from "react";
|
|
7
|
+
var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
|
|
8
|
+
function useForceUpdate() {
|
|
9
|
+
const [, force] = useReducer((c) => c + 1 | 0, 0);
|
|
10
|
+
return force;
|
|
11
|
+
}
|
|
12
|
+
function objectIsEqual(a, b) {
|
|
13
|
+
return Object.is(a, b);
|
|
14
|
+
}
|
|
15
|
+
function shallowEqualArray(a, b) {
|
|
16
|
+
if (a === b) return true;
|
|
17
|
+
if (a.length !== b.length) return false;
|
|
18
|
+
for (let i = 0; i < a.length; i++) {
|
|
19
|
+
if (!Object.is(a[i], b[i])) return false;
|
|
20
|
+
}
|
|
21
|
+
return true;
|
|
22
|
+
}
|
|
23
|
+
function setEqual(a, b) {
|
|
24
|
+
if (a === b) return true;
|
|
25
|
+
if (a.size !== b.size) return false;
|
|
26
|
+
for (const value of a) {
|
|
27
|
+
if (!b.has(value)) return false;
|
|
28
|
+
}
|
|
29
|
+
return true;
|
|
30
|
+
}
|
|
31
|
+
function useStableArray(input) {
|
|
32
|
+
const ref = useRef(input);
|
|
33
|
+
if (!shallowEqualArray(ref.current, input)) {
|
|
34
|
+
ref.current = input;
|
|
35
|
+
}
|
|
36
|
+
return ref.current;
|
|
37
|
+
}
|
|
38
|
+
function useFastReactiveValue(read, subscribe, isEqual, deps) {
|
|
39
|
+
const force = useForceUpdate();
|
|
40
|
+
const cache = useRef(null);
|
|
41
|
+
const incoming = read();
|
|
42
|
+
if (cache.current === null || !isEqual(cache.current.value, incoming)) {
|
|
43
|
+
cache.current = { value: incoming };
|
|
44
|
+
}
|
|
45
|
+
const value = cache.current.value;
|
|
46
|
+
useIsomorphicLayoutEffect(() => {
|
|
47
|
+
let active = true;
|
|
48
|
+
const onChange = () => {
|
|
49
|
+
if (!active) return;
|
|
50
|
+
const next = read();
|
|
51
|
+
if (cache.current !== null && isEqual(cache.current.value, next)) {
|
|
52
|
+
return;
|
|
53
|
+
}
|
|
54
|
+
cache.current = { value: next };
|
|
55
|
+
force();
|
|
56
|
+
};
|
|
57
|
+
const unsubscribe = subscribe(onChange);
|
|
58
|
+
const latest = read();
|
|
59
|
+
if (cache.current === null || !isEqual(cache.current.value, latest)) {
|
|
60
|
+
cache.current = { value: latest };
|
|
61
|
+
force();
|
|
62
|
+
}
|
|
63
|
+
return () => {
|
|
64
|
+
active = false;
|
|
65
|
+
unsubscribe();
|
|
66
|
+
};
|
|
67
|
+
}, deps);
|
|
68
|
+
return value;
|
|
69
|
+
}
|
|
70
|
+
var useSelectEntityByPkFast = (reactiveCollection, pk) => useFastReactiveValue(
|
|
71
|
+
() => reactiveCollection.getOneByPk(pk),
|
|
72
|
+
(onChange) => reactiveCollection.subscribeOnKey(pk, onChange),
|
|
73
|
+
objectIsEqual,
|
|
74
|
+
[reactiveCollection, pk]
|
|
75
|
+
);
|
|
76
|
+
var useSelectEntitiesByPksFast = (reactiveCollection, pks) => {
|
|
77
|
+
const stablePks = useStableArray(pks);
|
|
78
|
+
return useFastReactiveValue(
|
|
79
|
+
() => stablePks.map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
80
|
+
(onChange) => reactiveCollection.subscribeOnKeys(stablePks, onChange),
|
|
81
|
+
shallowEqualArray,
|
|
82
|
+
[reactiveCollection, stablePks]
|
|
83
|
+
);
|
|
84
|
+
};
|
|
85
|
+
var useSelectValueByObjectKeyFast = (reactiveObject, key) => useFastReactiveValue(
|
|
86
|
+
() => reactiveObject.get(key),
|
|
87
|
+
(onChange) => reactiveObject.subscribeOnKey(key, onChange),
|
|
88
|
+
objectIsEqual,
|
|
89
|
+
[reactiveObject, key]
|
|
90
|
+
);
|
|
91
|
+
var useSelectValuesByObjectKeysFast = (reactiveObject, keys) => {
|
|
92
|
+
const stableKeys = useStableArray(keys);
|
|
93
|
+
return useFastReactiveValue(
|
|
94
|
+
() => stableKeys.map((key) => reactiveObject.get(key)),
|
|
95
|
+
(onChange) => reactiveObject.subscribeOnKeys(stableKeys, onChange),
|
|
96
|
+
shallowEqualArray,
|
|
97
|
+
[reactiveObject, stableKeys]
|
|
98
|
+
);
|
|
99
|
+
};
|
|
100
|
+
var useSelectPksByIndexKeySetBasedFast = (reactiveIndex, key) => useFastReactiveValue(
|
|
101
|
+
() => reactiveIndex.getPksByKey(key),
|
|
102
|
+
(onChange) => reactiveIndex.subscribeOnKey(key, onChange),
|
|
103
|
+
setEqual,
|
|
104
|
+
[reactiveIndex, key]
|
|
105
|
+
);
|
|
106
|
+
var useSelectPksByIndexKeyArrayBasedFast = (reactiveIndex, key) => useFastReactiveValue(
|
|
107
|
+
() => reactiveIndex.getPksByKey(key),
|
|
108
|
+
(onChange) => reactiveIndex.subscribeOnKey(key, onChange),
|
|
109
|
+
shallowEqualArray,
|
|
110
|
+
[reactiveIndex, key]
|
|
111
|
+
);
|
|
112
|
+
var useSelectPksByIndexKeysSetBasedFast = (reactiveIndex, keys) => {
|
|
113
|
+
const stableKeys = useStableArray(keys);
|
|
114
|
+
return useFastReactiveValue(
|
|
115
|
+
() => stableKeys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat(),
|
|
116
|
+
(onChange) => reactiveIndex.subscribeOnKeys(stableKeys, onChange),
|
|
117
|
+
shallowEqualArray,
|
|
118
|
+
[reactiveIndex, stableKeys]
|
|
119
|
+
);
|
|
120
|
+
};
|
|
121
|
+
var useSelectPksByIndexKeysArrayBasedFast = (reactiveIndex, keys) => {
|
|
122
|
+
const stableKeys = useStableArray(keys);
|
|
123
|
+
return useFastReactiveValue(
|
|
124
|
+
() => stableKeys.map((key) => reactiveIndex.getPksByKey(key)).flat(),
|
|
125
|
+
(onChange) => reactiveIndex.subscribeOnKeys(stableKeys, onChange),
|
|
126
|
+
shallowEqualArray,
|
|
127
|
+
[reactiveIndex, stableKeys]
|
|
128
|
+
);
|
|
129
|
+
};
|
|
130
|
+
function subscribeIndexAndPks(subscribeIndex, subscribeCollection, readPks, onChange) {
|
|
131
|
+
let unsubscribeCollection = subscribeCollection(readPks(), onChange);
|
|
132
|
+
const unsubscribeIndex = subscribeIndex(() => {
|
|
133
|
+
unsubscribeCollection();
|
|
134
|
+
unsubscribeCollection = subscribeCollection(readPks(), onChange);
|
|
135
|
+
onChange();
|
|
136
|
+
});
|
|
137
|
+
return () => {
|
|
138
|
+
unsubscribeIndex();
|
|
139
|
+
unsubscribeCollection();
|
|
140
|
+
};
|
|
141
|
+
}
|
|
142
|
+
var useSelectEntitiesByIndexKeySetBasedFast = (reactiveCollection, reactiveIndex, key) => {
|
|
143
|
+
const readPks = () => Array.from(reactiveIndex.getPksByKey(key));
|
|
144
|
+
return useFastReactiveValue(
|
|
145
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
146
|
+
(onChange) => subscribeIndexAndPks(
|
|
147
|
+
(cb) => reactiveIndex.subscribeOnKey(key, cb),
|
|
148
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
149
|
+
readPks,
|
|
150
|
+
onChange
|
|
151
|
+
),
|
|
152
|
+
shallowEqualArray,
|
|
153
|
+
[reactiveCollection, reactiveIndex, key]
|
|
154
|
+
);
|
|
155
|
+
};
|
|
156
|
+
var useSelectEntitiesByIndexKeyArrayBasedFast = (reactiveCollection, reactiveIndex, key) => {
|
|
157
|
+
const readPks = () => reactiveIndex.getPksByKey(key);
|
|
158
|
+
return useFastReactiveValue(
|
|
159
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
160
|
+
(onChange) => subscribeIndexAndPks(
|
|
161
|
+
(cb) => reactiveIndex.subscribeOnKey(key, cb),
|
|
162
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
163
|
+
readPks,
|
|
164
|
+
onChange
|
|
165
|
+
),
|
|
166
|
+
shallowEqualArray,
|
|
167
|
+
[reactiveCollection, reactiveIndex, key]
|
|
168
|
+
);
|
|
169
|
+
};
|
|
170
|
+
var useSelectEntitiesByIndexKeysSetBasedFast = (reactiveCollection, reactiveIndex, keys) => {
|
|
171
|
+
const stableKeys = useStableArray(keys);
|
|
172
|
+
const readPks = () => stableKeys.flatMap((key) => Array.from(reactiveIndex.getPksByKey(key)));
|
|
173
|
+
return useFastReactiveValue(
|
|
174
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
175
|
+
(onChange) => subscribeIndexAndPks(
|
|
176
|
+
(cb) => reactiveIndex.subscribeOnKeys(stableKeys, cb),
|
|
177
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
178
|
+
readPks,
|
|
179
|
+
onChange
|
|
180
|
+
),
|
|
181
|
+
shallowEqualArray,
|
|
182
|
+
[reactiveCollection, reactiveIndex, stableKeys]
|
|
183
|
+
);
|
|
184
|
+
};
|
|
185
|
+
var useSelectEntitiesByIndexKeysArrayBasedFast = (reactiveCollection, reactiveIndex, keys) => {
|
|
186
|
+
const stableKeys = useStableArray(keys);
|
|
187
|
+
const readPks = () => stableKeys.flatMap((key) => reactiveIndex.getPksByKey(key));
|
|
188
|
+
return useFastReactiveValue(
|
|
189
|
+
() => readPks().map((pk) => reactiveCollection.getOneByPk(pk)),
|
|
190
|
+
(onChange) => subscribeIndexAndPks(
|
|
191
|
+
(cb) => reactiveIndex.subscribeOnKeys(stableKeys, cb),
|
|
192
|
+
(pks, cb) => reactiveCollection.subscribeOnKeys(pks, cb),
|
|
193
|
+
readPks,
|
|
194
|
+
onChange
|
|
195
|
+
),
|
|
196
|
+
shallowEqualArray,
|
|
197
|
+
[reactiveCollection, reactiveIndex, stableKeys]
|
|
198
|
+
);
|
|
199
|
+
};
|
|
200
|
+
|
|
201
|
+
// src/hooks/index.ts
|
|
4
202
|
var EMPTY_ARRAY = [];
|
|
5
203
|
var useSelectPksByIndexKeysSetBased = (reactiveIndex, keys) => {
|
|
6
|
-
const prevKeysRef =
|
|
204
|
+
const prevKeysRef = useRef2();
|
|
7
205
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
8
206
|
if (!keysAreEqual) {
|
|
9
207
|
prevKeysRef.current = keys;
|
|
10
208
|
}
|
|
11
209
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
12
|
-
const snapshotValueRef =
|
|
210
|
+
const snapshotValueRef = useRef2();
|
|
13
211
|
const subscribe = useMemo(() => {
|
|
14
212
|
snapshotValueRef.current = stableKeys.map((key) => Array.from(reactiveIndex.getPksByKey(key))).flat();
|
|
15
213
|
return (onStoreChange) => {
|
|
@@ -35,7 +233,7 @@ var useSelectPksByIndexKeysSetBased = (reactiveIndex, keys) => {
|
|
|
35
233
|
return snapshot;
|
|
36
234
|
};
|
|
37
235
|
var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
|
|
38
|
-
const snapshotValueRef =
|
|
236
|
+
const snapshotValueRef = useRef2();
|
|
39
237
|
const subscribe = useMemo(() => {
|
|
40
238
|
snapshotValueRef.current = reactiveIndex.getPksByKey(key);
|
|
41
239
|
return (onStoreChange) => {
|
|
@@ -55,13 +253,13 @@ var useSelectPksByIndexKeySetBased = (reactiveIndex, key) => {
|
|
|
55
253
|
return snapshot;
|
|
56
254
|
};
|
|
57
255
|
var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
|
|
58
|
-
const prevKeysRef =
|
|
256
|
+
const prevKeysRef = useRef2();
|
|
59
257
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
60
258
|
if (!keysAreEqual) {
|
|
61
259
|
prevKeysRef.current = keys;
|
|
62
260
|
}
|
|
63
261
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
64
|
-
const snapshotValueRef =
|
|
262
|
+
const snapshotValueRef = useRef2();
|
|
65
263
|
const subscribe = useMemo(() => {
|
|
66
264
|
snapshotValueRef.current = stableKeys.map((key) => reactiveIndex.getPksByKey(key)).flat();
|
|
67
265
|
return (onStoreChange) => {
|
|
@@ -87,12 +285,12 @@ var useSelectPksByIndexKeysArrayBased = (reactiveIndex, keys) => {
|
|
|
87
285
|
return snapshot;
|
|
88
286
|
};
|
|
89
287
|
var useSelectPksByIndexKeyArrayBased = (reactiveIndex, key) => {
|
|
90
|
-
const prevKeyRef =
|
|
288
|
+
const prevKeyRef = useRef2();
|
|
91
289
|
const keyAreEqual = prevKeyRef.current === key;
|
|
92
290
|
if (!keyAreEqual) {
|
|
93
291
|
prevKeyRef.current = key;
|
|
94
292
|
}
|
|
95
|
-
const snapshotValueRef =
|
|
293
|
+
const snapshotValueRef = useRef2();
|
|
96
294
|
const subscribe = useMemo(() => {
|
|
97
295
|
snapshotValueRef.current = reactiveIndex.getPksByKey(key);
|
|
98
296
|
return (onStoreChange) => {
|
|
@@ -149,13 +347,13 @@ var useSelectValueByObjectKey = (reactiveObject, key) => {
|
|
|
149
347
|
return snapshot;
|
|
150
348
|
};
|
|
151
349
|
var useSelectValuesByObjectKeys = (reactiveObject, keys) => {
|
|
152
|
-
const prevKeysRef =
|
|
350
|
+
const prevKeysRef = useRef2();
|
|
153
351
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
154
352
|
if (!keysAreEqual) {
|
|
155
353
|
prevKeysRef.current = keys;
|
|
156
354
|
}
|
|
157
355
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
158
|
-
const snapshotRef =
|
|
356
|
+
const snapshotRef = useRef2();
|
|
159
357
|
const subscribe = useMemo(() => {
|
|
160
358
|
snapshotRef.current = stableKeys.map((key) => reactiveObject.get(key));
|
|
161
359
|
return (onStoreChange) => {
|
|
@@ -191,13 +389,13 @@ function arraysEqual(a, b) {
|
|
|
191
389
|
return true;
|
|
192
390
|
}
|
|
193
391
|
var useSelectEntitiesByPks = (reactiveCollection, pks) => {
|
|
194
|
-
const prevPksRef =
|
|
392
|
+
const prevPksRef = useRef2();
|
|
195
393
|
const pksAreEqual = arraysEqual(prevPksRef.current || EMPTY_ARRAY, pks);
|
|
196
394
|
if (!pksAreEqual) {
|
|
197
395
|
prevPksRef.current = pks;
|
|
198
396
|
}
|
|
199
397
|
const stablePks = pksAreEqual ? prevPksRef.current ?? pks : pks;
|
|
200
|
-
const snapshotRef =
|
|
398
|
+
const snapshotRef = useRef2();
|
|
201
399
|
const subscribe = useMemo(() => {
|
|
202
400
|
snapshotRef.current = stablePks.map(
|
|
203
401
|
(pk) => reactiveCollection.getOneByPk(pk)
|
|
@@ -227,7 +425,7 @@ var useSelectEntitiesByPks = (reactiveCollection, pks) => {
|
|
|
227
425
|
return snapshot;
|
|
228
426
|
};
|
|
229
427
|
var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, key) => {
|
|
230
|
-
const snapshotRef =
|
|
428
|
+
const snapshotRef = useRef2();
|
|
231
429
|
const subscribe = useMemo(() => {
|
|
232
430
|
const readSnapshot = () => Array.from(
|
|
233
431
|
reactiveIndex.getPksByKey(key),
|
|
@@ -265,13 +463,13 @@ var useSelectEntitiesByIndexKeySetBased = (reactiveCollection, reactiveIndex, ke
|
|
|
265
463
|
return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
|
|
266
464
|
};
|
|
267
465
|
var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, keys) => {
|
|
268
|
-
const prevKeysRef =
|
|
466
|
+
const prevKeysRef = useRef2();
|
|
269
467
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
270
468
|
if (!keysAreEqual) {
|
|
271
469
|
prevKeysRef.current = keys;
|
|
272
470
|
}
|
|
273
471
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
274
|
-
const snapshotRef =
|
|
472
|
+
const snapshotRef = useRef2();
|
|
275
473
|
const subscribe = useMemo(() => {
|
|
276
474
|
const readPks = () => stableKeys.flatMap(
|
|
277
475
|
(key) => Array.from(reactiveIndex.getPksByKey(key))
|
|
@@ -311,7 +509,7 @@ var useSelectEntitiesByIndexKeysSetBased = (reactiveCollection, reactiveIndex, k
|
|
|
311
509
|
return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
|
|
312
510
|
};
|
|
313
511
|
var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex, key) => {
|
|
314
|
-
const snapshotRef =
|
|
512
|
+
const snapshotRef = useRef2();
|
|
315
513
|
const subscribe = useMemo(() => {
|
|
316
514
|
const readSnapshot = () => reactiveIndex.getPksByKey(key).map((pk) => reactiveCollection.getOneByPk(pk));
|
|
317
515
|
const readPks = () => reactiveIndex.getPksByKey(key);
|
|
@@ -346,13 +544,13 @@ var useSelectEntitiesByIndexKeyArrayBased = (reactiveCollection, reactiveIndex,
|
|
|
346
544
|
return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
|
|
347
545
|
};
|
|
348
546
|
var useSelectEntitiesByIndexKeysArrayBased = (reactiveCollection, reactiveIndex, keys) => {
|
|
349
|
-
const prevKeysRef =
|
|
547
|
+
const prevKeysRef = useRef2();
|
|
350
548
|
const keysAreEqual = arraysEqual(prevKeysRef.current || EMPTY_ARRAY, keys);
|
|
351
549
|
if (!keysAreEqual) {
|
|
352
550
|
prevKeysRef.current = keys;
|
|
353
551
|
}
|
|
354
552
|
const stableKeys = keysAreEqual ? prevKeysRef.current ?? keys : keys;
|
|
355
|
-
const snapshotRef =
|
|
553
|
+
const snapshotRef = useRef2();
|
|
356
554
|
const subscribe = useMemo(() => {
|
|
357
555
|
const readPks = () => stableKeys.flatMap((key) => reactiveIndex.getPksByKey(key));
|
|
358
556
|
const readSnapshot = () => readPks().map((pk) => reactiveCollection.getOneByPk(pk));
|
|
@@ -419,15 +617,27 @@ export {
|
|
|
419
617
|
createOIMCollectionsContext,
|
|
420
618
|
useOIMCollectionsContext,
|
|
421
619
|
useSelectEntitiesByIndexKeyArrayBased,
|
|
620
|
+
useSelectEntitiesByIndexKeyArrayBasedFast,
|
|
422
621
|
useSelectEntitiesByIndexKeySetBased,
|
|
622
|
+
useSelectEntitiesByIndexKeySetBasedFast,
|
|
423
623
|
useSelectEntitiesByIndexKeysArrayBased,
|
|
624
|
+
useSelectEntitiesByIndexKeysArrayBasedFast,
|
|
424
625
|
useSelectEntitiesByIndexKeysSetBased,
|
|
626
|
+
useSelectEntitiesByIndexKeysSetBasedFast,
|
|
425
627
|
useSelectEntitiesByPks,
|
|
628
|
+
useSelectEntitiesByPksFast,
|
|
426
629
|
useSelectEntityByPk,
|
|
630
|
+
useSelectEntityByPkFast,
|
|
427
631
|
useSelectPksByIndexKeyArrayBased,
|
|
632
|
+
useSelectPksByIndexKeyArrayBasedFast,
|
|
428
633
|
useSelectPksByIndexKeySetBased,
|
|
634
|
+
useSelectPksByIndexKeySetBasedFast,
|
|
429
635
|
useSelectPksByIndexKeysArrayBased,
|
|
636
|
+
useSelectPksByIndexKeysArrayBasedFast,
|
|
430
637
|
useSelectPksByIndexKeysSetBased,
|
|
638
|
+
useSelectPksByIndexKeysSetBasedFast,
|
|
431
639
|
useSelectValueByObjectKey,
|
|
432
|
-
|
|
640
|
+
useSelectValueByObjectKeyFast,
|
|
641
|
+
useSelectValuesByObjectKeys,
|
|
642
|
+
useSelectValuesByObjectKeysFast
|
|
433
643
|
};
|