1 package playwright
2
3 import (
4 "math"
5 "reflect"
6 "sync"
7 )
8
9 type (
10 eventRegister struct {
11 once []interface{}
12 on []interface{}
13 }
14 eventEmitter struct {
15 eventsMutex sync.Mutex
16 events map[string]*eventRegister
17 addEventHandlers []func(name string, handler interface{})
18 removeEventHandlers []func(name string, handler interface{})
19 }
20 )
21
22 func (e *eventEmitter) Emit(name string, payload ...interface{}) {
23 e.eventsMutex.Lock()
24 defer e.eventsMutex.Unlock()
25 if _, ok := e.events[name]; !ok {
26 return
27 }
28
29 payloadV := make([]reflect.Value, 0)
30
31 for _, p := range payload {
32 payloadV = append(payloadV, reflect.ValueOf(p))
33 }
34
35 callHandlers := func(handlers []interface{}) {
36 for _, handler := range handlers {
37 handlerV := reflect.ValueOf(handler)
38 handlerV.Call(payloadV[:int(math.Min(float64(handlerV.Type().NumIn()), float64(len(payloadV))))])
39 }
40 }
41
42 callHandlers(e.events[name].on)
43 callHandlers(e.events[name].once)
44
45 e.events[name].once = make([]interface{}, 0)
46 }
47
48 func (e *eventEmitter) Once(name string, handler interface{}) {
49 e.addEvent(name, handler, true)
50 }
51
52 func (e *eventEmitter) On(name string, handler interface{}) {
53 e.addEvent(name, handler, false)
54 }
55
56 func (e *eventEmitter) addEventHandler(handler func(name string, handler interface{})) {
57 e.addEventHandlers = append(e.addEventHandlers, handler)
58 }
59
60 func (e *eventEmitter) removeEventHandler(handler func(name string, handler interface{})) {
61 e.removeEventHandlers = append(e.removeEventHandlers, handler)
62 }
63
64 func (e *eventEmitter) RemoveListener(name string, handler interface{}) {
65 for _, mitm := range e.removeEventHandlers {
66 mitm(name, handler)
67 }
68 e.eventsMutex.Lock()
69 defer e.eventsMutex.Unlock()
70 if _, ok := e.events[name]; !ok {
71 return
72 }
73 handlerPtr := reflect.ValueOf(handler).Pointer()
74
75 onHandlers := []interface{}{}
76 for idx := range e.events[name].on {
77 eventPtr := reflect.ValueOf(e.events[name].on[idx]).Pointer()
78 if eventPtr != handlerPtr {
79 onHandlers = append(onHandlers, e.events[name].on[idx])
80 }
81 }
82 e.events[name].on = onHandlers
83
84 onceHandlers := []interface{}{}
85 for idx := range e.events[name].once {
86 eventPtr := reflect.ValueOf(e.events[name].once[idx]).Pointer()
87 if eventPtr != handlerPtr {
88 onceHandlers = append(onceHandlers, e.events[name].once[idx])
89 }
90 }
91
92 e.events[name].once = onceHandlers
93 }
94
95 func (e *eventEmitter) ListenerCount(name string) int {
96 count := 0
97 e.eventsMutex.Lock()
98 for key := range e.events {
99 count += len(e.events[key].on) + len(e.events[key].once)
100 }
101 e.eventsMutex.Unlock()
102 return count
103 }
104
105 func (e *eventEmitter) addEvent(name string, handler interface{}, once bool) {
106 for _, mitm := range e.addEventHandlers {
107 mitm(name, handler)
108 }
109 e.eventsMutex.Lock()
110 if _, ok := e.events[name]; !ok {
111 e.events[name] = &eventRegister{
112 on: make([]interface{}, 0),
113 once: make([]interface{}, 0),
114 }
115 }
116 if once {
117 e.events[name].once = append(e.events[name].once, handler)
118 } else {
119 e.events[name].on = append(e.events[name].on, handler)
120 }
121 e.eventsMutex.Unlock()
122 }
123
124 func (e *eventEmitter) initEventEmitter() {
125 e.events = make(map[string]*eventRegister)
126 }
127
View as plain text