-
Notifications
You must be signed in to change notification settings - Fork 12
/
entity.ts
115 lines (96 loc) · 2.64 KB
/
entity.ts
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import { atom, useAtom, useAtomValue } from 'jotai';
import { useCallback } from 'react';
import { WorkerEventType } from '../types/event';
import type { RegData, RegEntity } from '../types/reg';
import type { Store } from '../types/store';
import { toEntities } from '../utils/transformer';
import type { WorkerClient } from '../worker-client';
import { useWorkerClient } from './worker';
type EntityState = {
new: RegEntity[];
passed: RegEntity[];
failed: RegEntity[];
deleted: RegEntity[];
};
const defaultEntityAtom = atom<EntityState>({
new: [],
passed: [],
failed: [],
deleted: [],
});
const entityAtom = atom<EntityState>({
new: [],
passed: [],
failed: [],
deleted: [],
});
const allEntitiesAtom = atom((get) => {
const entity = get(entityAtom);
return entity.failed.concat(entity.new, entity.deleted, entity.passed);
});
const filteredAtom = atom(false);
export const initializeEntityState = (
store: Store,
data: RegData,
worker: WorkerClient,
) => {
const dirs = {
diff: data.diffDir,
expected: data.expectedDir,
actual: data.actualDir,
};
store.set(defaultEntityAtom, {
new: toEntities('new', dirs, data.newItems),
passed: toEntities('passed', dirs, data.passedItems),
failed: toEntities('changed', dirs, data.failedItems),
deleted: toEntities('deleted', dirs, data.deletedItems),
});
const defaultEntity = store.get(defaultEntityAtom);
store.set(entityAtom, {
...defaultEntity,
...store.get(defaultEntityAtom),
});
worker.requestFilterInit({
newItems: defaultEntity.new,
passedItems: defaultEntity.passed,
failedItems: defaultEntity.failed,
deletedItems: defaultEntity.deleted,
});
worker.subscribe(WorkerEventType.RESULT_FILTER, (payload) => {
store.set(entityAtom, {
new: payload.newItems,
passed: payload.passedItems,
failed: payload.failedItems,
deleted: payload.deletedItems,
});
});
};
export const useEntities = () => {
const entity = useAtomValue(entityAtom);
const allItems = useAtomValue(allEntitiesAtom);
return {
newItems: entity.new,
passedItems: entity.passed,
failedItems: entity.failed,
deletedItems: entity.deleted,
allItems,
};
};
export const useEntityFilter = () => {
const worker = useWorkerClient();
const [isFiltered, setIsFiltered] = useAtom(filteredAtom);
const filter = useCallback(
(input: string) => {
if (worker == null) {
return;
}
const value = input.trim();
setIsFiltered(value !== '');
worker.requestFilter({
input: value,
});
},
[worker, setIsFiltered],
);
return [isFiltered, filter] as const;
};