-
-
Notifications
You must be signed in to change notification settings - Fork 1.8k
/
when.ts
105 lines (99 loc) · 2.99 KB
/
when.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
import {
$mobx,
IReactionDisposer,
Lambda,
autorun,
createAction,
getNextId,
die,
allowStateChanges
} from "../internal"
// https://github.com/mobxjs/mobx/issues/3582
interface GenericAbortSignal {
readonly aborted: boolean
onabort?: ((...args: any) => any) | null
addEventListener?: (...args: any) => any
removeEventListener?: (...args: any) => any
}
export interface IWhenOptions {
name?: string
timeout?: number
onError?: (error: any) => void
signal?: GenericAbortSignal
}
export function when(
predicate: () => boolean,
opts?: IWhenOptions
): Promise<void> & { cancel(): void }
export function when(
predicate: () => boolean,
effect: Lambda,
opts?: IWhenOptions
): IReactionDisposer
export function when(predicate: any, arg1?: any, arg2?: any): any {
if (arguments.length === 1 || (arg1 && typeof arg1 === "object")) {
return whenPromise(predicate, arg1)
}
return _when(predicate, arg1, arg2 || {})
}
function _when(predicate: () => boolean, effect: Lambda, opts: IWhenOptions): IReactionDisposer {
let timeoutHandle: any
if (typeof opts.timeout === "number") {
const error = new Error("WHEN_TIMEOUT")
timeoutHandle = setTimeout(() => {
if (!disposer[$mobx].isDisposed_) {
disposer()
if (opts.onError) {
opts.onError(error)
} else {
throw error
}
}
}, opts.timeout)
}
opts.name = __DEV__ ? opts.name || "When@" + getNextId() : "When"
const effectAction = createAction(
__DEV__ ? opts.name + "-effect" : "When-effect",
effect as Function
)
// eslint-disable-next-line
var disposer = autorun(r => {
// predicate should not change state
let cond = allowStateChanges(false, predicate)
if (cond) {
r.dispose()
if (timeoutHandle) {
clearTimeout(timeoutHandle)
}
effectAction()
}
}, opts)
return disposer
}
function whenPromise(
predicate: () => boolean,
opts?: IWhenOptions
): Promise<void> & { cancel(): void } {
if (__DEV__ && opts && opts.onError) {
return die(`the options 'onError' and 'promise' cannot be combined`)
}
if (opts?.signal?.aborted) {
return Object.assign(Promise.reject(new Error("WHEN_ABORTED")), { cancel: () => null })
}
let cancel
let abort
const res = new Promise((resolve, reject) => {
let disposer = _when(predicate, resolve as Lambda, { ...opts, onError: reject })
cancel = () => {
disposer()
reject(new Error("WHEN_CANCELLED"))
}
abort = () => {
disposer()
reject(new Error("WHEN_ABORTED"))
}
opts?.signal?.addEventListener?.("abort", abort)
}).finally(() => opts?.signal?.removeEventListener?.("abort", abort))
;(res as any).cancel = cancel
return res as any
}