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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
import math
import times
import bindings/quickjs
import js/dict
import js/error
import js/fromjs
import js/javascript
import js/tojs
import types/opt
type
EventPhase = enum
NONE = 0u16
CAPTURING_PHASE = 1u16
AT_TARGET = 2u16
BUBBLING_PHASE = 3u16
EventFlag* = enum
FLAG_STOP_PROPAGATION
FLAG_STOP_IMMEDIATE_PROPAGATION
FLAG_CANCELED
FLAG_IN_PASSIVE_LISTENER
FLAG_COMPOSED
FLAG_INITIALIZED
FLAG_DISPATCH
Event* = ref object of RootObj
ctype {.jsget: "type".}: string
target* {.jsget.}: EventTarget
currentTarget* {.jsget.}: EventTarget
eventPhase {.jsget.}: uint16
bubbles {.jsget.}: bool
cancelable {.jsget.}: bool
#TODO DOMHighResTimeStamp?
timeStamp {.jsget.}: float64
flags*: set[EventFlag]
isTrusted {.jsufget.}: bool
CustomEvent* = ref object of Event
detail {.jsget.}: JSValue
EventTarget* = ref object of RootObj
eventListeners*: seq[EventListener]
EventHandler* = JSValue
EventListenerCallback = proc (event: Event): Err[JSError]
EventListener* = ref object
ctype*: string
callback*: EventListenerCallback
capture: bool
passive: Opt[bool]
once: bool
#TODO AbortSignal
removed: bool
jsDestructor(Event)
jsDestructor(CustomEvent)
jsDestructor(EventTarget)
# Forward declaration hack
var isDefaultPassive*: proc (eventTarget: EventTarget): bool
type
EventInit = object of JSDict
bubbles: bool
cancelable: bool
composed: bool
CustomEventInit = object of EventInit
detail: JSValue
# Event
proc innerEventCreationSteps(event: Event, eventInitDict: EventInit) =
event.flags = {FLAG_INITIALIZED}
#TODO this is probably incorrect?
# I think it measures the time since the first fork. not sure though
event.timeStamp = round(cpuTime())
event.bubbles = eventInitDict.bubbles
event.cancelable = eventInitDict.cancelable
if eventInitDict.composed:
event.flags.incl(FLAG_COMPOSED)
#TODO eventInitDict type
proc newEvent(ctype: string, eventInitDict = EventInit()):
JSResult[Event] {.jsctor.} =
let event = Event()
event.innerEventCreationSteps(eventInitDict)
event.ctype = ctype
return ok(event)
proc newEvent*(ctx: JSContext, ctype: string, target: EventTarget): Event =
return Event(
ctype: ctype,
target: target,
currentTarget: target
)
proc initialize(this: Event, ctype: string, bubbles, cancelable: bool) =
this.flags.incl(FLAG_INITIALIZED)
this.isTrusted = false
this.target = nil
this.ctype = ctype
this.bubbles = bubbles
this.cancelable = cancelable
proc initEvent(this: Event, ctype: string, bubbles, cancelable: bool)
{.jsfunc.} =
if FLAG_DISPATCH notin this.flags:
this.initialize(ctype, bubbles, cancelable)
func srcElement(this: Event): EventTarget {.jsfget.} =
return this.target
#TODO shadow DOM etc.
func composedPath(this: Event): seq[EventTarget] {.jsfunc.} =
if this.currentTarget == nil:
return @[]
return @[this.currentTarget]
proc stopPropagation(this: Event) {.jsfunc.} =
this.flags.incl(FLAG_STOP_PROPAGATION)
func cancelBubble(this: Event): bool {.jsfget.} =
return FLAG_STOP_PROPAGATION in this.flags
proc cancelBubble(this: Event, cancel: bool) {.jsfset.} =
if cancel:
this.stopPropagation()
proc stopImmediatePropagation(this: Event) {.jsfunc.} =
this.flags.incl({FLAG_STOP_PROPAGATION, FLAG_STOP_IMMEDIATE_PROPAGATION})
proc setCanceledFlag(this: Event) =
if this.cancelable and FLAG_IN_PASSIVE_LISTENER notin this.flags:
this.flags.incl(FLAG_CANCELED)
proc returnValue(this: Event): bool {.jsfget.} =
return FLAG_CANCELED notin this.flags
proc returnValue(this: Event, value: bool) {.jsfset.} =
if not value:
this.setCanceledFlag()
proc preventDefault(this: Event) {.jsfunc.} =
this.flags.incl(FLAG_CANCELED)
func defaultPrevented(this: Event): bool {.jsfget.} =
return FLAG_CANCELED in this.flags
func composed(this: Event): bool {.jsfget.} =
return FLAG_COMPOSED in this.flags
# CustomEvent
proc newCustomEvent(ctype: string, eventInitDict = CustomEventInit()):
JSResult[CustomEvent] {.jsctor.} =
let event = CustomEvent()
event.innerEventCreationSteps(eventInitDict)
event.detail = eventInitDict.detail
event.ctype = ctype
return ok(event)
proc finalize(rt: JSRuntime, this: CustomEvent) {.jsfin.} =
JS_FreeValueRT(rt, this.detail)
proc initCustomEvent(this: CustomEvent, ctype: string,
bubbles, cancelable: bool, detail: JSValue) {.jsfunc.} =
if FLAG_DISPATCH notin this.flags:
this.initialize(ctype, bubbles, cancelable)
this.detail = detail
# EventTarget
proc newEventTarget(): EventTarget {.jsctor.} =
return EventTarget()
proc defaultPassiveValue(ctype: string, eventTarget: EventTarget): bool =
if ctype in ["touchstart", "touchmove", "wheel", "mousewheel"]:
return true
return eventTarget.isDefaultPassive()
proc findEventListener(eventTarget: EventTarget, ctype: string,
callback: EventListenerCallback, capture: bool): int =
for i in 0 ..< eventTarget.eventListeners.len:
let it = eventTarget.eventListeners[i]
if it.ctype == ctype and it.callback == callback and it.capture == capture:
return i
return -1
# shared
proc addAnEventListener(eventTarget: EventTarget, listener: EventListener) =
#TODO signals
if listener.callback == nil:
return
if listener.passive.isNone:
listener.passive = opt(defaultPassiveValue(listener.ctype, eventTarget))
if eventTarget.findEventListener(listener.ctype, listener.callback,
listener.capture) == -1: # dedup
eventTarget.eventListeners.add(listener)
#TODO signals
proc removeAnEventListener(eventTarget: EventTarget, i: int) =
eventTarget.eventListeners[i].removed = true
eventTarget.eventListeners.delete(i)
proc flatten(ctx: JSContext, options: JSValue): bool =
if JS_IsBool(options):
return fromJS[bool](ctx, options).get(false)
if JS_IsObject(options):
let x = JS_GetPropertyStr(ctx, options, "capture")
return fromJS[bool](ctx, x).get(false)
return false
proc flattenMore(ctx: JSContext, options: JSValue):
tuple[
capture: bool,
once: bool,
passive: Opt[bool]
#TODO signals
] =
if JS_IsUndefined(options):
return
let capture = flatten(ctx, options)
var once = false
var passive: Opt[bool]
if JS_IsObject(options):
once = fromJS[bool](ctx, JS_GetPropertyStr(ctx, options, "once"))
.get(false)
let x = fromJS[bool](ctx, JS_GetPropertyStr(ctx, options, "passive"))
if x.isSome:
passive = opt(x.get)
return (capture, once, passive)
proc addEventListener(ctx: JSContext, eventTarget: EventTarget, ctype: string,
callback: EventListenerCallback, options = JS_UNDEFINED) {.jsfunc.} =
let (capture, once, passive) = flattenMore(ctx, options)
let listener = EventListener(
ctype: ctype,
capture: capture,
passive: passive,
once: once,
callback: callback
)
eventTarget.addAnEventListener(listener)
proc removeEventListener(ctx: JSContext, eventTarget: EventTarget,
ctype: string, callback: EventListenerCallback,
options = JS_UNDEFINED) {.jsfunc.} =
let capture = flatten(ctx, options)
let i = eventTarget.findEventListener(ctype, callback, capture)
if i != -1:
eventTarget.removeAnEventListener(i)
proc addEventModule*(ctx: JSContext) =
let eventCID = ctx.registerType(Event)
ctx.registerType(CustomEvent, parent = eventCID)
ctx.defineConsts(eventCID, EventPhase, uint16)
ctx.registerType(EventTarget)
|