1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
import { difference, intersection, isString } from "lodash";
import { useEffect, useMemo, useState } from "react";
import { useEffectOnceWhen } from "rooks";
import { useEntityIdByRange, useEntityToItem } from "./entity";
export function useNewEntityIds(entity: Async.Entity<any>) {
return useMemo(() => {
const dirtyEntities = entity.dirtyEntities;
const rawIds = entity.content.ids;
const ids = rawIds.filter(isString);
return difference(dirtyEntities, ids);
}, [entity.dirtyEntities, entity.content.ids]);
}
export function useDirtyEntityIds(
entity: Async.Entity<any>,
start: number,
end: number
) {
const ids = useEntityIdByRange(entity.content, start, end);
return useMemo(() => {
const dirtyIds = entity.dirtyEntities;
return intersection(ids, dirtyIds);
}, [ids, entity.dirtyEntities]);
}
export function useEntityItemById<T>(
entity: Async.Entity<T>,
id: string
): Async.Item<T> {
const { content, dirtyEntities, didLoaded, error, state } = entity;
const item = useEntityToItem(content, id);
const newState = useMemo<Async.State>(() => {
switch (state) {
case "loading":
return state;
default:
if (dirtyEntities.find((v) => v === id)) {
return "dirty";
} else if (!didLoaded.find((v) => v === id)) {
return "uninitialized";
} else {
return state;
}
}
}, [dirtyEntities, id, state, didLoaded]);
return useMemo(
() => ({ content: item, state: newState, error }),
[error, newState, item]
);
}
export function useOnLoadedOnce(callback: () => void, entity: Async.Base<any>) {
const [didLoaded, setLoaded] = useState(false);
const { state } = entity;
const isLoaded = state !== "loading";
useEffect(() => {
if (!isLoaded) {
setLoaded(true);
}
}, [isLoaded]);
useEffectOnceWhen(callback, didLoaded && isLoaded);
}
|
