HomePhorge
Diffusion Ant (type-hints-typescript) Code

ant/src/modules/events.c
899dad6b8a9etype-hints-typescript

Last Change
Raw File

events.c
View Options

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <time.h>
#include <uthash.h>
#include <utarray.h>
#include "ant.h"
#include "errors.h"
#include "runtime.h"
#include "internal.h"
#include "descriptors.h"
#include "silver/engine.h"
#include "gc/modules.h"
#include "modules/abort.h"
#include "modules/events.h"
#include "modules/symbol.h"
typedef struct {
bool canceled;
bool stop_immediate;
bool stop_propagation;
bool dispatching;
} event_data_t;
static ant_value_t g_isTrusted_getter = 0;
static ant_value_t g_eventemitter_ctor = 0;
static ant_value_t g_eventemitter_proto = 0;
static ant_value_t g_eventtarget_proto = 0;
static ant_value_t g_event_proto = 0;
static ant_value_t g_customevent_proto = 0;
static ant_value_t g_errorevent_proto = 0;
static ant_value_t g_promiserejectionevent_proto = 0;
static event_data_t *get_event_data(ant_value_t obj) {
ant_value_t slot = js_get_slot(obj, SLOT_DATA);
if (vtype(slot) != T_NUM) return NULL;
return (event_data_t *)(uintptr_t)js_getnum(slot);
}
static double get_timestamp_ms(void) {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec * 1e3 + (double)ts.tv_nsec / 1e6;
}
typedef struct {
ant_value_t callback;
ant_value_t raw_callback;
ant_value_t signal;
bool once;
bool capture;
} EventListenerEntry;
static const UT_icd event_listener_icd = {
sizeof(EventListenerEntry),
NULL, NULL, NULL
};
typedef struct {
unsigned char buf[48];
unsigned char *ptr;
size_t len;
} evt_key_t;
typedef struct {
UT_array *listeners;
ant_value_t js_key;
unsigned char *hash_key;
size_t hash_key_len;
bool warned_max_listeners;
UT_hash_handle hh;
} EventType;
typedef struct emitter_reg {
EventType **events;
struct emitter_reg *next;
} emitter_reg_t;
static EventType *global_events = NULL;
static emitter_reg_t *emitter_registry = NULL;
static EventType *make_event_type(ant_value_t js_key, const evt_key_t *ek) {
EventType *evt = ant_calloc(sizeof(EventType) + ek->len);
if (!evt) return NULL;
evt->js_key = js_key;
evt->hash_key = (unsigned char *)(evt + 1);
evt->hash_key_len = ek->len;
memcpy(evt->hash_key, ek->ptr, ek->len);
utarray_new(evt->listeners, &event_listener_icd);
return evt;
}
static EventType *evt_find(EventType *table, const evt_key_t *ek) {
EventType *evt = NULL;
HASH_FIND(hh, table, ek->ptr, ek->len, evt);
return evt;
}
static EventType *evt_find_or_create(EventType **table, ant_value_t js_key, const evt_key_t *ek) {
EventType *evt = evt_find(*table, ek);
if (!evt) {
evt = make_event_type(js_key, ek);
if (!evt) return NULL;
HASH_ADD_KEYPTR(hh, *table, evt->hash_key, evt->hash_key_len, evt);
}
return evt;
}
static void evt_key_reset(evt_key_t *k) {
k->ptr = k->buf;
k->len = 0;
}
static void evt_key_free(evt_key_t *k) {
if (k->ptr != k->buf) free(k->ptr);
evt_key_reset(k);
}
static bool evt_key_init(ant_t *js, ant_value_t arg, evt_key_t *out) {
evt_key_reset(out);
uint8_t tag = (uint8_t)vtype(arg);
if (tag == T_STR) {
size_t slen = 0;
const char *s = js_getstr(js, arg, &slen);
out->len = 1 + slen;
if (out->len > sizeof(out->buf)) {
out->ptr = malloc(out->len);
if (!out->ptr) { evt_key_reset(out); return false; }
}
out->ptr[0] = tag;
if (slen) memcpy(out->ptr + 1, s, slen);
return true;
}
if (tag == T_SYMBOL) {
out->len = 1 + sizeof(ant_value_t);
out->ptr[0] = tag;
memcpy(out->ptr + 1, &arg, sizeof(ant_value_t));
return true;
}
return false;
}
static EventType **get_or_create_emitter_events(ant_t *js, ant_value_t this_obj) {
ant_value_t slot = js_get_slot(this_obj, SLOT_DATA);
if (vtype(slot) == T_UNDEF) {
EventType **events = ant_calloc(sizeof(EventType *));
if (!events) return NULL;
*events = NULL;
emitter_reg_t *reg = ant_calloc(sizeof(emitter_reg_t));
if (!reg) { free(events); return NULL; }
reg->events = events;
reg->next = emitter_registry;
emitter_registry = reg;
js_set_slot(this_obj, SLOT_DATA, ANT_PTR(events));
return events;
}
return (EventType **)(uintptr_t)js_getnum(slot);
}
static EventType *find_or_create_global_event_type(ant_t *js, ant_value_t js_key) {
evt_key_t ek;
if (!evt_key_init(js, js_key, &ek)) return NULL;
EventType *evt = evt_find_or_create(&global_events, js_key, &ek);
evt_key_free(&ek);
return evt;
}
static EventType *find_global_event_type(ant_t *js, ant_value_t js_key) {
evt_key_t ek;
if (!evt_key_init(js, js_key, &ek)) return NULL;
EventType *evt = evt_find(global_events, &ek);
evt_key_free(&ek);
return evt;
}
static EventType *find_or_create_emitter_event_type(ant_t *js, ant_value_t this_obj, ant_value_t js_key) {
EventType **events = get_or_create_emitter_events(js, this_obj);
if (!events) return NULL;
evt_key_t ek;
if (!evt_key_init(js, js_key, &ek)) return NULL;
EventType *evt = evt_find_or_create(events, js_key, &ek);
evt_key_free(&ek);
return evt;
}
static EventType *find_emitter_event_type(ant_t *js, ant_value_t this_obj, ant_value_t js_key) {
EventType **events = get_or_create_emitter_events(js, this_obj);
if (!events) return NULL;
evt_key_t ek;
if (!evt_key_init(js, js_key, &ek)) return NULL;
EventType *evt = evt_find(*events, &ek);
evt_key_free(&ek);
return evt;
}
static inline ant_value_t evt_key_from_arg(ant_value_t arg) {
uint8_t t = vtype(arg);
return (t == T_STR || t == T_SYMBOL) ? arg : 0;
}
static bool is_eventemitter_instance(ant_value_t target) {
return js_check_brand(target, BRAND_EVENTEMITTER);
}
static bool is_eventtarget_instance(ant_value_t target) {
return js_check_brand(target, BRAND_EVENTTARGET);
}
static int eventemitter_get_max_listeners_impl(ant_value_t target) {
ant_value_t slot = js_get_slot(target, SLOT_EVENT_MAX_LISTENERS);
if (vtype(slot) == T_NUM) {
int n = (int)js_getnum(slot);
return n >= 0 ? n : EVENTS_DEFAULT_MAX_LISTENERS;
}
return EVENTS_DEFAULT_MAX_LISTENERS;
}
static ant_value_t eventemitter_call_listener(
ant_t *js,
ant_value_t listener,
ant_value_t this_val,
ant_value_t *args,
int nargs
) {
if (!is_callable(listener)) return js_mkundef();
if (sv_check_c_stack_overflow(js))
return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum call stack size exceeded");
sv_call_plan_t plan;
ant_value_t err = sv_prepare_call(
js->vm, js, listener, this_val, args, nargs,
NULL, SV_CALL_MODE_NORMAL, &plan
);
if (is_err(err)) return err;
return sv_execute_call_plan(js->vm, js, &plan, NULL);
}
static ant_value_t js_eventemitter_once_wrapper(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t listener = js_get_slot(js_getcurrentfunc(js), SLOT_DATA);
if (!is_callable(listener)) return js_mkundef();
return eventemitter_call_listener(js, listener, js->this_val, args, nargs);
}
static ant_value_t eventemitter_get_listeners_array(ant_t *js, ant_value_t target, ant_value_t key, bool raw) {
ant_value_t result = js_mkarr(js);
EventType *evt = NULL;
if (!is_object_type(target) || !key) return result;
evt = find_emitter_event_type(js, target, key);
if (!evt) return result;
for (unsigned int i = 0; i < utarray_len(evt->listeners); i++) {
EventListenerEntry *entry = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
if (!entry) continue;
js_arr_push(js, result, raw && entry->once && is_callable(entry->raw_callback)
? entry->raw_callback
: entry->callback
);
}
return result;
}
static void js_init_event_obj(ant_t *js, ant_value_t obj, ant_value_t type_val, bool bubbles, bool cancelable) {
js_set(js, obj, "type", type_val);
js_set(js, obj, "target", js_mknull());
js_set(js, obj, "srcElement", js_mknull());
js_set(js, obj, "currentTarget", js_mknull());
js_set(js, obj, "eventPhase", js_mknum(0));
js_set(js, obj, "bubbles", js_bool(bubbles));
js_set(js, obj, "cancelable", js_bool(cancelable));
js_set(js, obj, "defaultPrevented", js_false);
js_set(js, obj, "returnValue", js_true);
js_set(js, obj, "cancelBubble", js_false);
js_set(js, obj, "timeStamp", js_mknum(get_timestamp_ms()));
if (g_isTrusted_getter)
js_set_accessor_desc(js, obj, "isTrusted", 9, g_isTrusted_getter, js_mkundef(), 0);
event_data_t *data = ant_calloc(sizeof(event_data_t));
if (data) js_set_slot(obj, SLOT_DATA, ANT_PTR(data));
}
static ant_value_t js_event_ctor(ant_t *js, ant_value_t *args, int nargs) {
if (vtype(js->new_target) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "Event constructor requires 'new'");
if (nargs < 1 || vtype(args[0]) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "Event constructor: type argument is required");
ant_value_t type_val = args[0];
if (vtype(type_val) != T_STR) {
type_val = js_tostring_val(js, type_val);
if (is_err(type_val)) return type_val;
}
bool bubbles = false, cancelable = false;
if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
ant_value_t b = js_get(js, args[1], "bubbles");
ant_value_t c = js_get(js, args[1], "cancelable");
if (is_err(b)) return b;
if (is_err(c)) return c;
bubbles = js_truthy(js, b);
cancelable = js_truthy(js, c);
}
ant_value_t this_obj = js_mkobj(js);
ant_value_t proto = js_instance_proto_from_new_target(js, g_event_proto);
if (is_object_type(proto)) js_set_proto_init(this_obj, proto);
js_init_event_obj(js, this_obj, type_val, bubbles, cancelable);
return this_obj;
}
static ant_value_t js_event_get_isTrusted(ant_t *js, ant_value_t *args, int nargs) {
return js_false;
}
static ant_value_t js_eventemitter_ctor(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
if (is_object_type(this_obj)) {
js_set_slot(this_obj, SLOT_BRAND, js_mknum(BRAND_EVENTEMITTER));
return this_obj;
}
if (vtype(js->new_target) != T_UNDEF) {
ant_value_t obj = js_mkobj(js);
ant_value_t proto = js_instance_proto_from_new_target(js, g_eventemitter_proto);
if (is_object_type(proto)) js_set_proto_init(obj, proto);
js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_EVENTEMITTER));
return obj;
}
return js_mkerr_typed(js, JS_ERR_TYPE, "EventEmitter constructor requires an object receiver or 'new'");
}
static ant_value_t js_event_preventDefault(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
ant_value_t cancelable = js_get(js, this_obj, "cancelable");
if (!js_truthy(js, cancelable)) return js_mkundef();
event_data_t *data = get_event_data(this_obj);
if (data) data->canceled = true;
js_set(js, this_obj, "defaultPrevented", js_true);
js_set(js, this_obj, "returnValue", js_false);
return js_mkundef();
}
static ant_value_t js_event_stopPropagation(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
event_data_t *data = get_event_data(this_obj);
if (data) data->stop_propagation = true;
js_set(js, this_obj, "cancelBubble", js_true);
return js_mkundef();
}
static ant_value_t js_event_stopImmediatePropagation(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
event_data_t *data = get_event_data(this_obj);
if (data) { data->stop_immediate = true; data->stop_propagation = true; }
js_set(js, this_obj, "cancelBubble", js_true);
return js_mkundef();
}
static ant_value_t js_event_composedPath(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
event_data_t *data = get_event_data(this_obj);
ant_value_t result = js_mkarr(js);
if (data && data->dispatching) {
ant_value_t ct = js_get(js, this_obj, "currentTarget");
if (is_object_type(ct)) js_arr_push(js, result, ct);
}
return result;
}
static ant_value_t js_event_initEvent(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
if (nargs >= 1) {
ant_value_t type_val = vtype(args[0]) == T_STR ? args[0] : js_tostring_val(js, args[0]);
if (!is_err(type_val)) js_set(js, this_obj, "type", type_val);
}
if (nargs >= 2) js_set(js, this_obj, "bubbles", js_bool(js_truthy(js, args[1])));
if (nargs >= 3) js_set(js, this_obj, "cancelable", js_bool(js_truthy(js, args[2])));
js_set(js, this_obj, "defaultPrevented", js_false);
js_set(js, this_obj, "returnValue", js_true);
event_data_t *data = get_event_data(this_obj);
if (data) { data->canceled = false; data->stop_immediate = false; data->stop_propagation = false; }
return js_mkundef();
}
static ant_value_t js_customevent_ctor(ant_t *js, ant_value_t *args, int nargs) {
if (vtype(js->new_target) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "CustomEvent constructor requires 'new'");
if (nargs < 1 || vtype(args[0]) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "CustomEvent constructor: type argument is required");
ant_value_t type_val = args[0];
if (vtype(type_val) != T_STR) {
type_val = js_tostring_val(js, type_val);
if (is_err(type_val)) return type_val;
}
bool bubbles = false, cancelable = false;
ant_value_t detail = js_mknull();
if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
ant_value_t b = js_get(js, args[1], "bubbles");
ant_value_t c = js_get(js, args[1], "cancelable");
ant_value_t d = js_get(js, args[1], "detail");
if (is_err(b)) return b;
if (is_err(c)) return c;
bubbles = js_truthy(js, b);
cancelable = js_truthy(js, c);
if (vtype(d) != T_UNDEF) detail = d;
}
ant_value_t this_obj = js_mkobj(js);
ant_value_t proto = js_instance_proto_from_new_target(js, g_customevent_proto);
if (is_object_type(proto)) js_set_proto_init(this_obj, proto);
js_init_event_obj(js, this_obj, type_val, bubbles, cancelable);
js_set(js, this_obj, "detail", detail);
return this_obj;
}
static ant_value_t js_errorevent_ctor(ant_t *js, ant_value_t *args, int nargs) {
if (vtype(js->new_target) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "ErrorEvent constructor requires 'new'");
if (nargs < 1 || vtype(args[0]) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "ErrorEvent constructor: type argument is required");
ant_value_t type_val = args[0];
if (vtype(type_val) != T_STR) {
type_val = js_tostring_val(js, type_val);
if (is_err(type_val)) return type_val;
}
bool bubbles = false, cancelable = false;
ant_value_t message = js_mkstr(js, "", 0);
ant_value_t filename = js_mkstr(js, "", 0);
ant_value_t lineno = js_mknum(0);
ant_value_t colno = js_mknum(0);
ant_value_t error = js_mknull();
if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
ant_value_t b = js_get(js, args[1], "bubbles");
ant_value_t c = js_get(js, args[1], "cancelable");
ant_value_t m = js_get(js, args[1], "message");
ant_value_t f = js_get(js, args[1], "filename");
ant_value_t l = js_get(js, args[1], "lineno");
ant_value_t co = js_get(js, args[1], "colno");
ant_value_t e = js_get(js, args[1], "error");
if (is_err(b)) return b;
if (is_err(c)) return c;
bubbles = js_truthy(js, b);
cancelable = js_truthy(js, c);
if (vtype(m) != T_UNDEF) { message = js_tostring_val(js, m); if (is_err(message)) return message; }
if (vtype(f) != T_UNDEF) { filename = js_tostring_val(js, f); if (is_err(filename)) return filename; }
if (vtype(l) != T_UNDEF) lineno = l;
if (vtype(co) != T_UNDEF) colno = co;
if (vtype(e) != T_UNDEF) error = e;
}
ant_value_t this_obj = js_mkobj(js);
ant_value_t proto = js_instance_proto_from_new_target(js, g_errorevent_proto);
if (is_object_type(proto)) js_set_proto_init(this_obj, proto);
js_init_event_obj(js, this_obj, type_val, bubbles, cancelable);
js_set(js, this_obj, "message", message);
js_set(js, this_obj, "filename", filename);
js_set(js, this_obj, "lineno", lineno);
js_set(js, this_obj, "colno", colno);
js_set(js, this_obj, "error", error);
return this_obj;
}
static ant_value_t js_promiserejectionevent_ctor(ant_t *js, ant_value_t *args, int nargs) {
if (vtype(js->new_target) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "PromiseRejectionEvent constructor requires 'new'");
if (nargs < 1 || vtype(args[0]) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "PromiseRejectionEvent constructor: type argument is required");
ant_value_t type_val = args[0];
if (vtype(type_val) != T_STR) {
type_val = js_tostring_val(js, type_val);
if (is_err(type_val)) return type_val;
}
bool bubbles = false, cancelable = false;
ant_value_t promise = js_mkundef();
ant_value_t reason = js_mkundef();
if (nargs >= 2 && vtype(args[1]) == T_OBJ) {
ant_value_t b = js_get(js, args[1], "bubbles");
ant_value_t c = js_get(js, args[1], "cancelable");
ant_value_t p = js_get(js, args[1], "promise");
ant_value_t r = js_get(js, args[1], "reason");
if (is_err(b)) return b;
if (is_err(c)) return c;
bubbles = js_truthy(js, b);
cancelable = js_truthy(js, c);
if (vtype(p) != T_UNDEF) promise = p;
if (vtype(r) != T_UNDEF) reason = r;
}
ant_value_t this_obj = js_mkobj(js);
ant_value_t proto = js_instance_proto_from_new_target(js, g_promiserejectionevent_proto);
if (is_object_type(proto)) js_set_proto_init(this_obj, proto);
js_init_event_obj(js, this_obj, type_val, bubbles, cancelable);
js_set(js, this_obj, "promise", promise);
js_set(js, this_obj, "reason", reason);
return this_obj;
}
static ant_value_t js_eventtarget_ctor(ant_t *js, ant_value_t *args, int nargs) {
if (vtype(js->new_target) == T_UNDEF)
return js_mkerr_typed(js, JS_ERR_TYPE, "EventTarget constructor requires 'new'");
ant_value_t this_obj = js_getthis(js);
if (is_object_type(this_obj)) js_set_slot(this_obj, SLOT_BRAND, js_mknum(BRAND_EVENTTARGET));
return js_mkundef();
}
static bool parse_addEventListener_options(ant_t *js, ant_value_t *args, int nargs, bool *once, bool *capture, ant_value_t *signal) {
*once = false; *capture = false; *signal = js_mkundef();
if (nargs < 3) return true;
ant_value_t opts = args[2];
if (vtype(opts) == T_BOOL) {
*capture = js_truthy(js, opts);
return true;
}
if (vtype(opts) != T_OBJ) return true;
ant_value_t sig = js_get(js, opts, "signal");
if (vtype(sig) == T_NULL) return false;
if (vtype(sig) != T_UNDEF) {
if (!abort_signal_is_signal(sig)) return false;
*signal = sig;
}
ant_value_t o = js_get(js, opts, "once");
ant_value_t ca = js_get(js, opts, "capture");
if (vtype(o) != T_UNDEF) *once = js_truthy(js, o);
if (vtype(ca) != T_UNDEF) *capture = js_truthy(js, ca);
return true;
}
static ant_value_t add_listener_to(ant_t *js, ant_value_t *args, int nargs, EventType *evt) {
if (!evt) return js_mkerr(js, "failed to create event type");
bool once, capture;
ant_value_t signal;
if (!parse_addEventListener_options(js, args, nargs, &once, &capture, &signal))
return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to execute 'addEventListener': signal is not an AbortSignal");
if (vtype(signal) != T_UNDEF && abort_signal_is_aborted(signal)) return js_mkundef();
ant_value_t cb = args[1];
uint8_t cbt = vtype(cb);
if (cbt == T_NULL || cbt == T_UNDEF) return js_mkundef();
if (cbt != T_FUNC && cbt != T_CFUNC) return js_mkundef();
for (unsigned int i = 0; i < utarray_len(evt->listeners); i++) {
EventListenerEntry *e = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
if (e->callback == cb && e->capture == capture) return js_mkundef();
}
EventListenerEntry entry = { cb, js_mkundef(), signal, once, capture };
utarray_push_back(evt->listeners, &entry);
return js_mkundef();
}
static ant_value_t remove_listener_from(ant_t *js, ant_value_t *args, int nargs, EventType *evt) {
if (!evt) return js_mkundef();
bool capture = false;
if (nargs >= 3) {
ant_value_t opts = args[2];
if (vtype(opts) == T_BOOL) capture = js_truthy(js, opts);
else if (vtype(opts) == T_OBJ) {
ant_value_t ca = js_get(js, opts, "capture");
if (vtype(ca) != T_UNDEF) capture = js_truthy(js, ca);
}}
ant_value_t cb = (nargs >= 2) ? args[1] : js_mkundef();
uint8_t cbt = vtype(cb);
if (cbt == T_NULL || cbt == T_UNDEF) return js_mkundef();
for (unsigned int i = 0; i < utarray_len(evt->listeners); i++) {
EventListenerEntry *e = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
if (e->callback == cb && e->capture == capture) {
utarray_erase(evt->listeners, i, 1);
return js_mkundef();
}
}
return js_mkundef();
}
static ant_value_t dispatch_event_to(ant_t *js, ant_value_t event_obj, EventType *evt, ant_value_t target) {
if (!evt) return js_true;
event_data_t *data = get_event_data(event_obj);
if (data) { data->dispatching = true; data->stop_immediate = false; }
js_set(js, event_obj, "target", target);
js_set(js, event_obj, "currentTarget", target);
js_set(js, event_obj, "eventPhase", js_mknum(2));
ant_value_t call_args[1] = { event_obj };
unsigned int n = utarray_len(evt->listeners);
for (unsigned int i = 0; i < n;) {
EventListenerEntry *entry = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
if (vtype(entry->signal) != T_UNDEF && abort_signal_is_aborted(entry->signal)) {
utarray_erase(evt->listeners, i, 1);
n--; continue;
}
ant_value_t cb = entry->callback;
bool once = entry->once;
if (once) { utarray_erase(evt->listeners, i, 1); n--; } else i++;
uint8_t t = vtype(cb);
if (t != T_FUNC && t != T_CFUNC) continue;
eventemitter_call_listener(js, cb, js_mkundef(), call_args, 1);
if (data && data->stop_immediate) break;
}
if (data) data->dispatching = false;
js_set(js, event_obj, "currentTarget", js_mknull());
js_set(js, event_obj, "eventPhase", js_mknum(0));
bool canceled = data && data->canceled;
return js_bool(!canceled);
}
static ant_value_t js_add_event_listener_method(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkundef();
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkundef();
return add_listener_to(js, args, nargs,
find_or_create_emitter_event_type(js, js_getthis(js), key));
}
static ant_value_t js_add_event_listener(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkundef();
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkundef();
return add_listener_to(js, args, nargs, find_or_create_global_event_type(js, key));
}
static ant_value_t js_remove_event_listener_method(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkundef();
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkundef();
return remove_listener_from(js, args, nargs,
find_emitter_event_type(js, js_getthis(js), key));
}
static ant_value_t js_remove_event_listener(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkundef();
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkundef();
return remove_listener_from(js, args, nargs, find_global_event_type(js, key));
}
static ant_value_t js_dispatch_event_method(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1 || !is_object_type(args[0])) return js_false;
ant_value_t this_obj = js_getthis(js);
ant_value_t key = js_get(js, args[0], "type");
if (!evt_key_from_arg(key)) return js_false;
return dispatch_event_to(js, args[0],
find_emitter_event_type(js, this_obj, key), this_obj);
}
static ant_value_t js_dispatch_event(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1 || !is_object_type(args[0])) return js_false;
ant_value_t key = js_get(js, args[0], "type");
if (!evt_key_from_arg(key)) return js_false;
return dispatch_event_to(js, args[0],
find_global_event_type(js, key), js_glob(js));
}
void js_dispatch_global_event(ant_t *js, ant_value_t event_obj) {
ant_value_t key = js_get(js, event_obj, "type");
if (!evt_key_from_arg(key)) return;
EventType *evt = find_global_event_type(js, key);
if (!evt || utarray_len(evt->listeners) == 0) return;
dispatch_event_to(js, event_obj, evt, js_glob(js));
}
static bool eventemitter_add_listener_impl(
ant_t *js,
ant_value_t target, ant_value_t key,
ant_value_t listener, bool once, bool prepend
) {
EventType *evt = NULL;
EventListenerEntry entry = {0};
uint8_t t = 0;
if (!is_object_type(target) || !key) return false;
t = vtype(listener);
if (t != T_FUNC && t != T_CFUNC) return false;
evt = find_or_create_emitter_event_type(js, target, key);
if (!evt) return false;
entry.callback = listener;
entry.raw_callback = js_mkundef();
entry.signal = js_mkundef();
entry.once = once;
entry.capture = false;
if (once) {
entry.raw_callback = js_heavy_mkfun(js, js_eventemitter_once_wrapper, listener);
if (is_callable(entry.raw_callback)) js_set(js, entry.raw_callback, "listener", listener);
}
if (!prepend || utarray_len(evt->listeners) == 0) utarray_push_back(evt->listeners, &entry);
else {
utarray_push_back(evt->listeners, &entry);
EventListenerEntry *items = (EventListenerEntry *)utarray_eltptr(evt->listeners, 0);
if (!items) return false;
memmove(items + 1, items, (utarray_len(evt->listeners) - 1u) * sizeof(*items));
items[0] = entry;
}
int max_listeners = eventemitter_get_max_listeners_impl(target);
if (
max_listeners > 0 &&
!evt->warned_max_listeners &&
(int)utarray_len(evt->listeners) > max_listeners
) {
evt->warned_max_listeners = true;
if (vtype(key) == T_STR) {
fprintf(
stderr,
"Warning: Possible EventEmitter memory leak detected. "
"%u '%s' listeners added. Use emitter.setMaxListeners() to increase limit.\n",
(unsigned)utarray_len(evt->listeners),
js_str(js, key)
);
} else {
fprintf(
stderr,
"Warning: Possible EventEmitter memory leak detected. "
"%u listeners added for a Symbol event. Use emitter.setMaxListeners() to increase limit.\n",
(unsigned)utarray_len(evt->listeners)
);
}
}
return true;
}
static bool eventemitter_remove_listener_impl(
ant_t *js,
ant_value_t target, ant_value_t key,
ant_value_t listener
) {
EventType *evt = NULL;
uint8_t t = 0;
if (!is_object_type(target) || !key) return false;
t = vtype(listener);
if (t != T_FUNC && t != T_CFUNC) return false;
evt = find_emitter_event_type(js, target, key);
if (!evt) return false;
for (unsigned int i = 0; i < utarray_len(evt->listeners); i++) {
EventListenerEntry *entry = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
if (entry->callback == listener || entry->raw_callback == listener) {
utarray_erase(evt->listeners, i, 1);
return true;
}}
return false;
}
static ant_offset_t eventemitter_listener_count_impl(
ant_t *js,
ant_value_t target, ant_value_t key
) {
EventType *evt = NULL;
if (!is_object_type(target) || !key) return 0;
evt = find_emitter_event_type(js, target, key);
if (!evt) return 0;
return (ant_offset_t)utarray_len(evt->listeners);
}
static ant_value_t js_eventemitter_off(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 2) return js_mkerr(js, "off requires 2 arguments (event, listener)");
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkerr(js, "event must be a string or Symbol");
ant_value_t this_obj = js_getthis(js);
remove_listener_from(
js, args, nargs,
find_emitter_event_type(js, this_obj, key)
);
return this_obj;
}
static bool eventemitter_emit_args_impl(
ant_t *js,
ant_value_t target, ant_value_t key,
ant_value_t *args, int nargs
) {
EventType *evt = NULL;
if (!is_object_type(target) || !key) return false;
evt = find_emitter_event_type(js, target, key);
if (!evt || utarray_len(evt->listeners) == 0) return false;
for (unsigned int i = 0; i < utarray_len(evt->listeners);) {
EventListenerEntry *entry = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
ant_value_t cb = entry->callback;
bool once = entry->once;
if (once) utarray_erase(evt->listeners, i, 1);
else i++;
if (vtype(entry->signal) != T_UNDEF && abort_signal_is_aborted(entry->signal)) continue;
if (vtype(cb) != T_FUNC && vtype(cb) != T_CFUNC) continue;
ant_value_t result = eventemitter_call_listener(js, cb, target, args, nargs);
if (vtype(result) == T_ERR) {
if (vtype(key) == T_STR) fprintf(stderr, "Error in event listener for '%s': %s\n", js_str(js, key), js_str(js, result));
else fprintf(stderr, "Error in event listener: %s\n", js_str(js, result));
}
}
return true;
}
static ant_value_t js_eventemitter_emit(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkerr(js, "emit requires at least 1 argument (event)");
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkerr(js, "event must be a string or Symbol");
return js_bool(eventemitter_emit_args_impl(
js, js_getthis(js), key,
nargs > 1 ? &args[1] : NULL, nargs - 1
));
}
bool eventemitter_emit_args_val(
ant_t *js,
ant_value_t target, ant_value_t key,
ant_value_t *args, int nargs
) {
return eventemitter_emit_args_impl(js, target, key, args, nargs);
}
bool eventemitter_emit_args(
ant_t *js,
ant_value_t target, const char *event_type,
ant_value_t *args, int nargs
) {
return eventemitter_emit_args_val(js, target, js_mkstr(js, event_type, strlen(event_type)), args, nargs);
}
bool eventemitter_add_listener_val(
ant_t *js,
ant_value_t target, ant_value_t key,
ant_value_t listener, bool once
) {
return eventemitter_add_listener_impl(js, target, key, listener, once, false);
}
bool eventemitter_add_listener(
ant_t *js,
ant_value_t target, const char *event_type,
ant_value_t listener, bool once
) {
return eventemitter_add_listener_val(js, target, js_mkstr(js, event_type, strlen(event_type)), listener, once);
}
bool eventemitter_remove_listener_val(
ant_t *js,
ant_value_t target, ant_value_t key,
ant_value_t listener
) {
return eventemitter_remove_listener_impl(js, target, key, listener);
}
bool eventemitter_remove_listener(
ant_t *js,
ant_value_t target, const char *event_type,
ant_value_t listener
) {
return eventemitter_remove_listener_val(js, target, js_mkstr(js, event_type, strlen(event_type)), listener);
}
ant_offset_t eventemitter_listener_count_val(
ant_t *js,
ant_value_t target, ant_value_t key
) {
return eventemitter_listener_count_impl(js, target, key);
}
ant_offset_t eventemitter_listener_count(
ant_t *js,
ant_value_t target, const char *event_type
) {
return eventemitter_listener_count_val(js, target, js_mkstr(js, event_type, strlen(event_type)));
}
static ant_value_t js_eventemitter_add(ant_t *js, ant_value_t *args, int nargs, bool once, bool prepend) {
if (nargs < 2) return js_mkerr(js, "requires 2 arguments (event, listener)");
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkerr(js, "event must be a string or Symbol");
if (!eventemitter_add_listener_impl(js, js_getthis(js), key, args[1], once, prepend))
return js_mkerr(js, "listener must be a function");
return js_getthis(js);
}
static ant_value_t js_eventemitter_on(ant_t *js, ant_value_t *args, int nargs) {
return js_eventemitter_add(js, args, nargs, false, false);
}
static ant_value_t js_eventemitter_once(ant_t *js, ant_value_t *args, int nargs) {
return js_eventemitter_add(js, args, nargs, true, false);
}
static ant_value_t js_eventemitter_prepend_listener(ant_t *js, ant_value_t *args, int nargs) {
return js_eventemitter_add(js, args, nargs, false, true);
}
static ant_value_t js_eventemitter_prepend_once_listener(ant_t *js, ant_value_t *args, int nargs) {
return js_eventemitter_add(js, args, nargs, true, true);
}
static ant_value_t js_eventemitter_removeAllListeners(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
EventType **events = NULL;
if (nargs < 1 || vtype(args[0]) == T_UNDEF) {
events = get_or_create_emitter_events(js, this_obj);
if (!events || !*events) return this_obj;
EventType *evt, *tmp;
HASH_ITER(hh, *events, evt, tmp) utarray_clear(evt->listeners);
return this_obj;
}
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return this_obj;
EventType *evt = find_emitter_event_type(js, this_obj, key);
if (evt) utarray_clear(evt->listeners);
return this_obj;
}
static ant_value_t js_eventemitter_listenerCount(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mknum(0);
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mknum(0);
EventType *evt = find_emitter_event_type(js, js_getthis(js), key);
if (!evt) return js_mknum(0);
return js_mknum((double)utarray_len(evt->listeners));
}
static ant_value_t js_eventemitter_setMaxListeners(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkerr(js, "setMaxListeners requires 1 argument");
if (vtype(args[0]) != T_NUM) return js_mkerr(js, "n must be a number");
int n = (int)js_getnum(args[0]);
if (n < 0) return js_mkerr(js, "n must be non-negative");
ant_value_t this_obj = js_getthis(js);
if (!is_object_type(this_obj)) return js_mkerr_typed(js, JS_ERR_TYPE, "setMaxListeners requires an object receiver");
js_set_slot(this_obj, SLOT_EVENT_MAX_LISTENERS, js_mknum(n));
return this_obj;
}
static ant_value_t js_eventemitter_getMaxListeners(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
if (!is_object_type(this_obj)) return js_mknum(EVENTS_DEFAULT_MAX_LISTENERS);
return js_mknum(eventemitter_get_max_listeners_impl(this_obj));
}
static ant_value_t js_eventemitter_rawListeners(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkarr(js);
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkarr(js);
return eventemitter_get_listeners_array(js, js_getthis(js), key, true);
}
static ant_value_t js_eventemitter_listeners(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkarr(js);
ant_value_t key = evt_key_from_arg(args[0]);
if (!key) return js_mkarr(js);
return eventemitter_get_listeners_array(js, js_getthis(js), key, false);
}
static ant_value_t js_eventemitter_eventNames(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t this_obj = js_getthis(js);
ant_value_t result = js_mkarr(js);
EventType **events = get_or_create_emitter_events(js, this_obj);
if (events && *events) {
EventType *evt, *tmp;
HASH_ITER(hh, *events, evt, tmp) if (utarray_len(evt->listeners) > 0)
js_arr_push(js, result, evt->js_key);
}
return result;
}
static ant_value_t js_events_once_listener(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t state = js_get_slot(js_getcurrentfunc(js), SLOT_DATA);
if (!is_object_type(state)) return js_mkundef();
ant_value_t promise = js_get_slot(state, SLOT_DATA);
if (vtype(promise) != T_PROMISE) return js_mkundef();
ant_value_t settled = js_get_slot(state, SLOT_SETTLED);
if (vtype(settled) == T_BOOL && settled == js_true) return js_mkundef();
js_set_slot(state, SLOT_SETTLED, js_true);
ant_value_t signal = js_get(js, state, "signal");
ant_value_t abort_listener = js_get(js, state, "abortListener");
if (abort_signal_is_signal(signal) && is_callable(abort_listener))
abort_signal_remove_listener(js, signal, abort_listener);
ant_value_t values = js_mkarr(js);
for (int i = 0; i < nargs; i++) js_arr_push(js, values, args[i]);
js_resolve_promise(js, promise, values);
return js_mkundef();
}
static ant_value_t js_events_once_abort_listener(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t state = js_get_slot(js_getcurrentfunc(js), SLOT_DATA);
if (!is_object_type(state)) return js_mkundef();
ant_value_t promise = js_get_slot(state, SLOT_DATA);
if (vtype(promise) != T_PROMISE) return js_mkundef();
ant_value_t settled = js_get_slot(state, SLOT_SETTLED);
if (vtype(settled) == T_BOOL && settled == js_true) return js_mkundef();
js_set_slot(state, SLOT_SETTLED, js_true);
ant_value_t signal = js_get(js, state, "signal");
ant_value_t abort_listener = js_get(js, state, "abortListener");
if (abort_signal_is_signal(signal) && is_callable(abort_listener))
abort_signal_remove_listener(js, signal, abort_listener);
ant_value_t reason = abort_signal_get_reason(signal);
if (vtype(reason) == T_UNDEF) reason = js_mkerr(js, "The operation was aborted");
js_reject_promise(js, promise, reason);
return js_mkundef();
}
static bool js_events_once_is_abort_key(ant_t *js, ant_value_t key) {
size_t key_len = 0;
const char *key_str = vtype(key) == T_STR ? js_getstr(js, key, &key_len) : NULL;
return key_str && key_len == 5 && memcmp(key_str, "abort", 5) == 0;
}
static void js_events_once_reject_aborted(ant_t *js, ant_value_t promise, ant_value_t signal) {
ant_value_t reason = abort_signal_get_reason(signal);
if (vtype(reason) == T_UNDEF) reason = js_mkerr(js, "The operation was aborted");
js_reject_promise(js, promise, reason);
}
static ant_value_t js_events_once_attach(
ant_t *js,
ant_value_t promise,
ant_value_t target,
ant_value_t key,
ant_value_t listener,
ant_value_t signal
) {
if (abort_signal_is_signal(target)) {
if (!js_events_once_is_abort_key(js, key)) {
js_reject_promise(js, promise, js_mkerr_typed(js, JS_ERR_TYPE, "AbortSignal only supports the abort event"));
return promise;
}
abort_signal_add_listener(js, target, listener);
return promise;
}
if (is_eventemitter_instance(target)) {
if (!eventemitter_add_listener_val(js, target, key, listener, true))
js_reject_promise(js, promise, js_mkerr(js, "listener must be a function"));
return promise;
}
if (is_eventtarget_instance(target)) {
ant_value_t listener_options = js_mkobj(js);
js_set(js, listener_options, "once", js_true);
if (abort_signal_is_signal(signal)) js_set(js, listener_options, "signal", signal);
ant_value_t call_args[3] = { key, listener, listener_options };
ant_value_t result = add_listener_to(js, call_args, 3, find_or_create_emitter_event_type(js, target, key));
if (is_err(result)) js_reject_promise(js, promise, result);
return promise;
}
js_reject_promise(js, promise, js_mkerr_typed(js, JS_ERR_TYPE, "target is not an EventEmitter or EventTarget"));
return promise;
}
static ant_value_t js_events_once(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 2 || !is_object_type(args[0]))
return js_mkerr_typed(js, JS_ERR_TYPE, "events.once requires an emitter and event name");
ant_value_t key = evt_key_from_arg(args[1]);
if (!key) return js_mkerr_typed(js, JS_ERR_TYPE, "event must be a string or Symbol");
ant_value_t promise = js_mkpromise(js);
if (is_err(promise)) return promise;
ant_value_t state = js_mkobj(js);
js_set_slot(state, SLOT_DATA, promise);
js_set_slot(state, SLOT_SETTLED, js_false);
ant_value_t listener = js_heavy_mkfun(js, js_events_once_listener, state);
ant_value_t target = args[0];
ant_value_t options = nargs >= 3 ? args[2] : js_mkundef();
ant_value_t signal = js_mkundef();
if (is_object_type(options)) signal = js_get(js, options, "signal");
if (abort_signal_is_signal(signal)) {
if (abort_signal_is_aborted(signal)) {
js_events_once_reject_aborted(js, promise, signal);
return promise;
}
ant_value_t abort_listener = js_heavy_mkfun(js, js_events_once_abort_listener, state);
js_set(js, state, "signal", signal);
js_set(js, state, "abortListener", abort_listener);
abort_signal_add_listener(js, signal, abort_listener);
}
return js_events_once_attach(js, promise, target, key, listener, signal);
}
static ant_value_t js_events_disposable_dispose(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t state = js_get_slot(js_getcurrentfunc(js), SLOT_DATA);
if (!is_object_type(state)) return js_mkundef();
ant_value_t disposed = js_get_slot(state, SLOT_SETTLED);
if (vtype(disposed) == T_BOOL && disposed == js_true) return js_mkundef();
js_set_slot(state, SLOT_SETTLED, js_true);
ant_value_t signal = js_get(js, state, "signal");
ant_value_t listener = js_get(js, state, "listener");
if (abort_signal_is_signal(signal) && is_callable(listener))
abort_signal_remove_listener(js, signal, listener);
return js_mkundef();
}
static ant_value_t js_events_add_abort_listener(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 2 || !abort_signal_is_signal(args[0]) || !is_callable(args[1]))
return js_mkerr_typed(js, JS_ERR_TYPE, "events.addAbortListener requires an AbortSignal and listener");
bool already_aborted = abort_signal_is_aborted(args[0]);
if (already_aborted) {
ant_value_t event = js_mkobj(js);
js_set(js, event, "type", js_mkstr(js, "abort", 5));
eventemitter_call_listener(js, args[1], args[0], &event, 1);
} else abort_signal_add_listener(js, args[0], args[1]);
ant_value_t state = js_mkobj(js);
js_set_slot(state, SLOT_SETTLED, js_bool(already_aborted));
js_set(js, state, "signal", args[0]);
js_set(js, state, "listener", args[1]);
ant_value_t disposable = js_mkobj(js);
js_set(js, disposable, "dispose", js_heavy_mkfun(js, js_events_disposable_dispose, state));
return disposable;
}
static ant_value_t js_events_set_max_listeners(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mkerr(js, "setMaxListeners requires at least 1 argument");
if (vtype(args[0]) != T_NUM) return js_mkerr(js, "n must be a number");
int n = (int)js_getnum(args[0]);
if (n < 0) return js_mkerr(js, "n must be non-negative");
for (int i = 1; i < nargs; i++) {
if (!is_object_type(args[i])) continue;
js_set_slot(args[i], SLOT_EVENT_MAX_LISTENERS, js_mknum(n));
}
return js_mkundef();
}
static ant_value_t js_events_get_max_listeners(ant_t *js, ant_value_t *args, int nargs) {
if (nargs < 1) return js_mknum(EVENTS_DEFAULT_MAX_LISTENERS);
if (!is_object_type(args[0])) return js_mknum(EVENTS_DEFAULT_MAX_LISTENERS);
return js_mknum(eventemitter_get_max_listeners_impl(args[0]));
}
// TODO: fix stub
static ant_value_t js_events_on(ant_t *js, ant_value_t *args, int nargs) {
return js_mkerr_typed(js, JS_ERR_TYPE, "events.on async iterator is not implemented");
}
ant_value_t events_library(ant_t *js) {
ant_value_t lib = js_mkobj(js);
eventemitter_prototype(js);
js_set_module_default(js, lib, g_eventemitter_ctor, "EventEmitter");
js_set(js, lib, "once", js_mkfun(js_events_once));
js_set(js, lib, "on", js_mkfun(js_events_on));
js_set(js, lib, "addAbortListener", js_mkfun(js_events_add_abort_listener));
js_set(js, lib, "setMaxListeners", js_mkfun(js_events_set_max_listeners));
js_set(js, lib, "getMaxListeners", js_mkfun(js_events_get_max_listeners));
js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "events", 6));
return lib;
}
ant_value_t eventemitter_prototype(ant_t *js) {
if (g_eventemitter_proto) return g_eventemitter_proto;
ant_value_t object_proto = js->sym.object_proto;
ant_value_t function_proto = js_get_slot(js_glob(js), SLOT_FUNC_PROTO);
if (vtype(function_proto) == T_UNDEF) function_proto = js_get_ctor_proto(js, "Function", 8);
ant_value_t eventemitter_ctor = js_mkobj(js);
ant_value_t eventemitter_proto = js_mkobj(js);
if (is_object_type(object_proto)) js_set_proto_init(eventemitter_proto, object_proto);
if (is_object_type(function_proto)) js_set_proto_init(eventemitter_ctor, function_proto);
js_set(js, eventemitter_proto, "on", js_mkfun(js_eventemitter_on));
js_set_exact(js, eventemitter_proto, "addListener", js_get(js, eventemitter_proto, "on"));
js_set(js, eventemitter_proto, "once", js_mkfun(js_eventemitter_once));
js_set(js, eventemitter_proto, "prependListener", js_mkfun(js_eventemitter_prepend_listener));
js_set(js, eventemitter_proto, "prependOnceListener", js_mkfun(js_eventemitter_prepend_once_listener));
js_set(js, eventemitter_proto, "off", js_mkfun(js_eventemitter_off));
js_set_exact(js, eventemitter_proto, "removeListener", js_get(js, eventemitter_proto, "off"));
js_set(js, eventemitter_proto, "emit", js_mkfun(js_eventemitter_emit));
js_set(js, eventemitter_proto, "removeAllListeners", js_mkfun(js_eventemitter_removeAllListeners));
js_set(js, eventemitter_proto, "listenerCount", js_mkfun(js_eventemitter_listenerCount));
js_set(js, eventemitter_proto, "setMaxListeners", js_mkfun(js_eventemitter_setMaxListeners));
js_set(js, eventemitter_proto, "getMaxListeners", js_mkfun(js_eventemitter_getMaxListeners));
js_set(js, eventemitter_proto, "listeners", js_mkfun(js_eventemitter_listeners));
js_set(js, eventemitter_proto, "rawListeners", js_mkfun(js_eventemitter_rawListeners));
js_set(js, eventemitter_proto, "eventNames", js_mkfun(js_eventemitter_eventNames));
js_set_sym(js, eventemitter_proto, get_toStringTag_sym(), js_mkstr(js, "EventEmitter", 12));
js_set_slot(eventemitter_ctor, SLOT_CFUNC, js_mkfun(js_eventemitter_ctor));
js_mkprop_fast(js, eventemitter_ctor, "prototype", 9, eventemitter_proto);
js_mkprop_fast(js, eventemitter_ctor, "name", 4, ANT_STRING("EventEmitter"));
js_set_descriptor(js, eventemitter_ctor, "name", 4, 0);
g_eventemitter_proto = eventemitter_proto;
g_eventemitter_ctor = js_obj_to_func(eventemitter_ctor);
js_set(js, eventemitter_proto, "constructor", g_eventemitter_ctor);
js_set_descriptor(js, eventemitter_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
return g_eventemitter_proto;
}
void init_events_module(void) {
ant_t *js = rt->js;
ant_value_t global = js_glob(js);
g_isTrusted_getter = js_mkfun(js_event_get_isTrusted);
g_event_proto = js_mkobj(js);
js_set_sym(js, g_event_proto, get_toStringTag_sym(), js_mkstr(js, "Event", 5));
js_set(js, g_event_proto, "preventDefault", js_mkfun(js_event_preventDefault));
js_set(js, g_event_proto, "stopPropagation", js_mkfun(js_event_stopPropagation));
js_set(js, g_event_proto, "stopImmediatePropagation", js_mkfun(js_event_stopImmediatePropagation));
js_set(js, g_event_proto, "composedPath", js_mkfun(js_event_composedPath));
js_set(js, g_event_proto, "initEvent", js_mkfun(js_event_initEvent));
js_set(js, g_event_proto, "NONE", js_mknum(0));
js_set(js, g_event_proto, "CAPTURING_PHASE", js_mknum(1));
js_set(js, g_event_proto, "AT_TARGET", js_mknum(2));
js_set(js, g_event_proto, "BUBBLING_PHASE", js_mknum(3));
ant_value_t event_fn = js_make_ctor(js, js_event_ctor, g_event_proto, "Event", 5);
js_set(js, event_fn, "NONE", js_mknum(0));
js_set(js, event_fn, "CAPTURING_PHASE", js_mknum(1));
js_set(js, event_fn, "AT_TARGET", js_mknum(2));
js_set(js, event_fn, "BUBBLING_PHASE", js_mknum(3));
js_set(js, global, "Event", event_fn);
g_customevent_proto = js_mkobj(js);
js_set_proto_init(g_customevent_proto, g_event_proto);
js_set_sym(js, g_customevent_proto, get_toStringTag_sym(), js_mkstr(js, "CustomEvent", 11));
ant_value_t customevent_fn = js_make_ctor(js, js_customevent_ctor, g_customevent_proto, "CustomEvent", 11);
js_set(js, global, "CustomEvent", customevent_fn);
g_errorevent_proto = js_mkobj(js);
js_set_proto_init(g_errorevent_proto, g_event_proto);
js_set_sym(js, g_errorevent_proto, get_toStringTag_sym(), js_mkstr(js, "ErrorEvent", 10));
ant_value_t errorevent_fn = js_make_ctor(js, js_errorevent_ctor, g_errorevent_proto, "ErrorEvent", 10);
js_set(js, global, "ErrorEvent", errorevent_fn);
g_promiserejectionevent_proto = js_mkobj(js);
js_set_proto_init(g_promiserejectionevent_proto, g_event_proto);
js_set_sym(js, g_promiserejectionevent_proto, get_toStringTag_sym(), js_mkstr(js, "PromiseRejectionEvent", 21));
ant_value_t pre_fn = js_make_ctor(js, js_promiserejectionevent_ctor, g_promiserejectionevent_proto, "PromiseRejectionEvent", 21);
js_set(js, global, "PromiseRejectionEvent", pre_fn);
ant_value_t object_proto = js->sym.object_proto;
ant_value_t function_proto = js_get_slot(global, SLOT_FUNC_PROTO);
if (vtype(function_proto) == T_UNDEF) function_proto = js_get_ctor_proto(js, "Function", 8);
ant_value_t eventtarget_proto = js_mkobj(js);
g_eventtarget_proto = eventtarget_proto;
if (is_object_type(object_proto)) js_set_proto_init(eventtarget_proto, object_proto);
js_set(js, eventtarget_proto, "addEventListener", js_mkfun(js_add_event_listener_method));
js_set(js, eventtarget_proto, "removeEventListener", js_mkfun(js_remove_event_listener_method));
js_set(js, eventtarget_proto, "dispatchEvent", js_mkfun(js_dispatch_event_method));
js_set_sym(js, eventtarget_proto, get_toStringTag_sym(), js_mkstr(js, "EventTarget", 11));
ant_value_t eventtarget_ctor = js_mkobj(js);
if (is_object_type(function_proto)) js_set_proto_init(eventtarget_ctor, function_proto);
js_set_slot(eventtarget_ctor, SLOT_CFUNC, js_mkfun(js_eventtarget_ctor));
js_mkprop_fast(js, eventtarget_ctor, "prototype", 9, eventtarget_proto);
js_mkprop_fast(js, eventtarget_ctor, "name", 4, ANT_STRING("EventTarget"));
js_set_descriptor(js, eventtarget_ctor, "name", 4, 0);
ant_value_t eventtarget_fn = js_obj_to_func(eventtarget_ctor);
js_set(js, eventtarget_proto, "constructor", eventtarget_fn);
js_set_descriptor(js, eventtarget_proto, "constructor", 11, JS_DESC_W | JS_DESC_C);
js_set(js, global, "addEventListener", js_mkfun(js_add_event_listener));
js_set(js, global, "removeEventListener", js_mkfun(js_remove_event_listener));
js_set(js, global, "dispatchEvent", js_mkfun(js_dispatch_event));
js_set(js, global, "EventTarget", eventtarget_fn);
}
static void mark_event_type_listeners(ant_t *js, gc_mark_fn mark, EventType *events) {
EventType *evt, *tmp;
HASH_ITER(hh, events, evt, tmp) {
if (vtype(evt->js_key) == T_STR) mark(js, evt->js_key);
for (unsigned int i = 0; i < utarray_len(evt->listeners); i++) {
EventListenerEntry *e = (EventListenerEntry *)utarray_eltptr(evt->listeners, i);
mark(js, e->callback);
if (vtype(e->raw_callback) != T_UNDEF) mark(js, e->raw_callback);
if (vtype(e->signal) != T_UNDEF) mark(js, e->signal);
}
}}
void gc_mark_events(ant_t *js, gc_mark_fn mark) {
mark_event_type_listeners(js, mark, global_events);
for (emitter_reg_t *reg = emitter_registry; reg; reg = reg->next) {
if (*reg->events) mark_event_type_listeners(js, mark, *reg->events);
}
if (g_isTrusted_getter) mark(js, g_isTrusted_getter);
if (g_eventemitter_ctor) mark(js, g_eventemitter_ctor);
if (g_eventemitter_proto) mark(js, g_eventemitter_proto);
if (g_eventtarget_proto) mark(js, g_eventtarget_proto);
if (g_event_proto) mark(js, g_event_proto);
if (g_customevent_proto) mark(js, g_customevent_proto);
if (g_errorevent_proto) mark(js, g_errorevent_proto);
if (g_promiserejectionevent_proto) mark(js, g_promiserejectionevent_proto);
}

Owner Packages

  • No Owners