HomePhorge
Diffusion Ant (type-hints-typescript) Code

ant/src/streams/transform.c
899dad6b8a9etype-hints-typescript

Last Change
Raw File

transform.c
View Options

#include <stdlib.h>
#include <string.h>
#include "ant.h"
#include "errors.h"
#include "runtime.h"
#include "internal.h"
#include "descriptors.h"
#include "gc/roots.h"
#include "silver/engine.h"
#include "modules/assert.h"
#include "modules/symbol.h"
#include "streams/transform.h"
#include "streams/readable.h"
#include "streams/writable.h"
ant_value_t g_ts_proto;
ant_value_t g_ts_ctrl_proto;
static inline bool ts_has_stream_shape(ant_value_t obj) {
return vtype(js_get_slot(obj, SLOT_DATA)) == T_NUM
&& rs_is_stream(js_get_slot(obj, SLOT_ENTRIES))
&& ws_is_stream(js_get_slot(obj, SLOT_CTOR));
}
static inline bool ts_has_controller_shape(ant_value_t obj) {
ant_value_t ts_obj = js_get_slot(obj, SLOT_DATA);
return is_object_type(ts_obj)
&& js_check_brand(ts_obj, BRAND_TRANSFORM_STREAM)
&& vtype(js_get_slot(ts_obj, SLOT_DATA)) == T_NUM
&& js_get_slot(ts_obj, SLOT_DEFAULT) == obj;
}
bool ts_is_controller(ant_value_t obj) {
return js_check_brand(obj, BRAND_TRANSFORM_STREAM_CONTROLLER)
&& ts_has_controller_shape(obj);
}
bool ts_is_stream(ant_value_t obj) {
ant_value_t ctrl_obj = js_get_slot(obj, SLOT_DEFAULT);
return js_check_brand(obj, BRAND_TRANSFORM_STREAM)
&& ts_has_stream_shape(obj)
&& js_check_brand(ctrl_obj, BRAND_TRANSFORM_STREAM_CONTROLLER)
&& ts_has_controller_shape(ctrl_obj);
}
ant_value_t ts_stream_readable(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_ENTRIES);
}
ant_value_t ts_stream_writable(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_CTOR);
}
static void ts_ws_finalize(ant_t *js, ant_object_t *obj) {
if (!obj->extra_slots) return;
ant_extra_slot_t *entries = (ant_extra_slot_t *)obj->extra_slots;
for (uint8_t i = 0; i < obj->extra_count; i++) {
if (entries[i].slot == SLOT_DATA && vtype(entries[i].value) == T_NUM) {
free((ws_stream_t *)(uintptr_t)(size_t)js_getnum(entries[i].value));
return;
}}
}
static void ts_ws_ctrl_finalize(ant_t *js, ant_object_t *obj) {
if (!obj->extra_slots) return;
ant_extra_slot_t *entries = (ant_extra_slot_t *)obj->extra_slots;
for (uint8_t i = 0; i < obj->extra_count; i++) {
if (entries[i].slot == SLOT_DATA && vtype(entries[i].value) == T_NUM) {
ws_controller_t *ctrl = (ws_controller_t *)(uintptr_t)(size_t)js_getnum(entries[i].value);
free(ctrl->queue_sizes);
free(ctrl);
return;
}}
}
static void ts_rs_finalize(ant_t *js, ant_object_t *obj) {
if (!obj->extra_slots) return;
ant_extra_slot_t *entries = (ant_extra_slot_t *)obj->extra_slots;
for (uint8_t i = 0; i < obj->extra_count; i++) {
if (entries[i].slot == SLOT_DATA && vtype(entries[i].value) == T_NUM) {
free((rs_stream_t *)(uintptr_t)(size_t)js_getnum(entries[i].value));
return;
}}
}
static void ts_rs_ctrl_finalize(ant_t *js, ant_object_t *obj) {
if (!obj->extra_slots) return;
ant_extra_slot_t *entries = (ant_extra_slot_t *)obj->extra_slots;
for (uint8_t i = 0; i < obj->extra_count; i++) {
if (entries[i].slot == SLOT_DATA && vtype(entries[i].value) == T_NUM) {
rs_controller_t *ctrl = (rs_controller_t *)(uintptr_t)(size_t)js_getnum(entries[i].value);
free(ctrl->queue_sizes);
free(ctrl);
return;
}}
}
static inline bool ts_get_backpressure(ant_value_t ts_obj) {
return js_getnum(js_get_slot(ts_obj, SLOT_DATA)) != 0;
}
static inline void ts_set_bp_flag(ant_value_t ts_obj, bool bp) {
js_set_slot(ts_obj, SLOT_DATA, js_mknum(bp ? 1 : 0));
}
static inline ant_value_t ts_readable(ant_value_t ts_obj) {
return ts_stream_readable(ts_obj);
}
static inline ant_value_t ts_writable(ant_value_t ts_obj) {
return ts_stream_writable(ts_obj);
}
static inline ant_value_t ts_bp_promise(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_AUX);
}
ant_value_t ts_stream_controller(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_DEFAULT);
}
static inline ant_value_t ts_controller(ant_value_t ts_obj) {
return ts_stream_controller(ts_obj);
}
static inline ant_value_t ts_ctrl_transform_fn(ant_value_t ctrl_obj) {
return js_get_slot(ctrl_obj, SLOT_ENTRIES);
}
static inline ant_value_t ts_ctrl_flush_fn(ant_value_t ctrl_obj) {
return js_get_slot(ctrl_obj, SLOT_CTOR);
}
static inline ant_value_t ts_ctrl_cancel_fn(ant_value_t ctrl_obj) {
return js_get_slot(ctrl_obj, SLOT_AUX);
}
static inline ant_value_t ts_ctrl_transformer(ant_value_t ctrl_obj) {
return js_get_slot(ctrl_obj, SLOT_SETTLED);
}
static inline ant_value_t ts_ctrl_stream(ant_value_t ctrl_obj) {
return js_get_slot(ctrl_obj, SLOT_DATA);
}
static inline ant_value_t ts_ctrl_finish_promise(ant_value_t ctrl_obj) {
return js_get_slot(ctrl_obj, SLOT_RS_PULL);
}
static inline ant_value_t ts_writable_stored_error(ant_value_t ts_obj) {
return js_get_slot(ts_writable(ts_obj), SLOT_AUX);
}
static inline ant_value_t ts_cancel_promise(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_RS_CANCEL);
}
static inline bool ts_cancel_started_by_abort(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_WS_ABORT) == js_true;
}
static inline bool ts_is_flushing(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_WS_CLOSE) == js_true;
}
static inline ant_value_t ts_cancel_settle_error(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_RS_SIZE);
}
static inline bool ts_cancel_joined_abort(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_WS_WRITE) == js_true;
}
static inline bool ts_cancel_has_user_handler(ant_value_t ts_obj) {
return js_get_slot(ts_obj, SLOT_WS_SIGNAL) == js_true;
}
static inline void ts_set_flushing(ant_value_t ts_obj, bool flushing) {
js_set_slot(ts_obj, SLOT_WS_CLOSE, flushing ? js_true : js_false);
}
static inline void ts_set_cancel_state(ant_t *js, ant_value_t ts_obj, ant_value_t promise, bool started_by_abort, bool has_user_handler) {
js_set_slot_wb(js, ts_obj, SLOT_RS_CANCEL, promise);
js_set_slot(ts_obj, SLOT_WS_ABORT, started_by_abort ? js_true : js_false);
js_set_slot(ts_obj, SLOT_RS_SIZE, js_mkundef());
js_set_slot(ts_obj, SLOT_WS_WRITE, js_false);
js_set_slot(ts_obj, SLOT_WS_SIGNAL, has_user_handler ? js_true : js_false);
}
static inline void ts_clear_cancel_state(ant_value_t ts_obj, ant_value_t promise) {
if (ts_cancel_promise(ts_obj) == promise) {
js_set_slot(ts_obj, SLOT_RS_CANCEL, js_mkundef());
js_set_slot(ts_obj, SLOT_WS_ABORT, js_false);
js_set_slot(ts_obj, SLOT_WS_SIGNAL, js_false);
}}
static void ts_ctrl_clear_algorithms(ant_value_t ctrl_obj) {
js_set_slot(ctrl_obj, SLOT_ENTRIES, js_mkundef());
js_set_slot(ctrl_obj, SLOT_CTOR, js_mkundef());
js_set_slot(ctrl_obj, SLOT_AUX, js_mkundef());
}
static ant_value_t ts_take_thrown_or(ant_t *js, ant_value_t fallback) {
ant_value_t thrown = js->thrown_exists ? js->thrown_value : js_mkundef();
ant_value_t err = is_object_type(thrown) ? thrown : fallback;
js->thrown_exists = false;
js->thrown_value = js_mkundef();
js->thrown_stack = js_mkundef();
return err;
}
static void ts_chain_promise(ant_t *js, ant_value_t val, ant_value_t res_fn, ant_value_t rej_fn) {
GC_ROOT_SAVE(root_mark, js);
GC_ROOT_PIN(js, val);
GC_ROOT_PIN(js, res_fn);
GC_ROOT_PIN(js, rej_fn);
ant_value_t promise = val;
GC_ROOT_PIN(js, promise);
if (vtype(promise) != T_PROMISE) {
promise = js_mkpromise(js);
GC_ROOT_PIN(js, promise);
js_resolve_promise(js, promise, val);
}
ant_value_t then_result = js_promise_then(js, promise, res_fn, rej_fn);
GC_ROOT_PIN(js, then_result);
promise_mark_handled(then_result);
GC_ROOT_RESTORE(js, root_mark);
}
static void ts_error(ant_t *js, ant_value_t ts_obj, ant_value_t e) {
ant_value_t readable = ts_readable(ts_obj);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_controller_t *rc = rs_get_controller(rs_ctrl);
if (rc) {
rc->queue_total_size = 0;
rc->queue_sizes_len = 0;
rs_default_controller_clear_algorithms(rs_ctrl);
}
readable_stream_error(js, readable, e);
if (ts_get_backpressure(ts_obj)) {
ant_value_t bp = ts_bp_promise(ts_obj);
if (vtype(bp) == T_PROMISE) js_resolve_promise(js, bp, js_mkundef());
ts_set_bp_flag(ts_obj, false);
}
}
static void ts_error_writable_and_unblock_write(ant_t *js, ant_value_t ts_obj, ant_value_t e) {
ant_value_t ctrl_obj = ts_controller(ts_obj);
ts_ctrl_clear_algorithms(ctrl_obj);
ant_value_t writable = ts_writable(ts_obj);
ws_stream_t *ws = ws_get_stream(writable);
if (ws && ws->state == WS_STATE_WRITABLE)
ws_default_controller_error(js, ws_stream_controller(writable), e);
if (ts_get_backpressure(ts_obj)) {
ant_value_t bp = ts_bp_promise(ts_obj);
if (vtype(bp) == T_PROMISE) js_resolve_promise(js, bp, js_mkundef());
ts_set_bp_flag(ts_obj, false);
}
}
static void ts_set_backpressure(ant_t *js, ant_value_t ts_obj, bool backpressure) {
if (ts_get_backpressure(ts_obj)) {
ant_value_t bp = ts_bp_promise(ts_obj);
if (vtype(bp) == T_PROMISE) js_resolve_promise(js, bp, js_mkundef());
}
ant_value_t new_bp = js_mkpromise(js);
js_set_slot_wb(js, ts_obj, SLOT_AUX, new_bp);
ts_set_bp_flag(ts_obj, backpressure);
}
ant_value_t ts_ctrl_enqueue(ant_t *js, ant_value_t ctrl_obj, ant_value_t chunk) {
ant_value_t ts_obj = ts_ctrl_stream(ctrl_obj);
ant_value_t readable = ts_readable(ts_obj);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_stream_t *rs = rs_get_stream(readable);
if (!rs || rs->state != RS_STATE_READABLE)
return js_mkerr_typed(js, JS_ERR_TYPE, "Readable side is not in a readable state");
ant_value_t enqueue_result = rs_controller_enqueue(js, rs_ctrl, chunk);
if (is_err(enqueue_result)) {
ant_value_t err = ts_take_thrown_or(js, enqueue_result);
ts_error_writable_and_unblock_write(js, ts_obj, err);
return js_throw(js, err);
}
rs_controller_t *rc = rs_get_controller(rs_ctrl);
bool bp = rc && ((rc->strategy_hwm - rc->queue_total_size) <= 0);
if (bp != ts_get_backpressure(ts_obj)) ts_set_backpressure(js, ts_obj, bp);
return js_mkundef();
}
void ts_ctrl_error(ant_t *js, ant_value_t ctrl_obj, ant_value_t e) {
ant_value_t ts_obj = ts_ctrl_stream(ctrl_obj);
if (vtype(ts_cancel_promise(ts_obj)) == T_PROMISE && ts_cancel_has_user_handler(ts_obj))
js_set_slot_wb(js, ts_obj, SLOT_RS_SIZE, e);
ts_error(js, ts_obj, e);
ts_error_writable_and_unblock_write(js, ts_obj, e);
}
void ts_ctrl_terminate(ant_t *js, ant_value_t ctrl_obj) {
ant_value_t ts_obj = ts_ctrl_stream(ctrl_obj);
ant_value_t readable = ts_readable(ts_obj);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_controller_close(js, rs_ctrl);
ant_value_t writable = ts_writable(ts_obj);
ws_stream_t *ws = ws_get_stream(writable);
if (ws && ws->state == WS_STATE_WRITABLE) {
ant_value_t err = js_make_error_silent(js, JS_ERR_TYPE, "TransformStream readable side terminated");
ts_error_writable_and_unblock_write(js, ts_obj, err);
}
}
static ant_value_t ts_transform_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t p = js_get_slot(js->current_func, SLOT_DATA);
js_resolve_promise(js, p, js_mkundef());
return js_mkundef();
}
static ant_value_t ts_transform_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t e = (nargs > 0) ? args[0] : js_mkundef();
ts_error(js, ts_obj, e);
js_reject_promise(js, p, e);
return js_mkundef();
}
static ant_value_t ts_ctrl_perform_transform(ant_t *js, ant_value_t ctrl_obj, ant_value_t chunk) {
ant_value_t transform_fn = ts_ctrl_transform_fn(ctrl_obj);
ant_value_t ts_obj = ts_ctrl_stream(ctrl_obj);
ant_value_t p = js_mkpromise(js);
promise_mark_handled(p);
if (is_callable(transform_fn)) {
ant_value_t call_args[2] = { chunk, ctrl_obj };
ant_value_t result = sv_vm_call(js->vm, js, transform_fn, ts_ctrl_transformer(ctrl_obj), call_args, 2, NULL, false);
if (is_err(result)) {
ant_value_t err = ts_take_thrown_or(js, result);
ts_error(js, ts_obj, err);
js_reject_promise(js, p, err);
return p;
}
ant_value_t res_fn = js_heavy_mkfun(js, ts_transform_resolve, p);
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, p);
js_set_slot(wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_transform_reject, wrapper);
ts_chain_promise(js, result, res_fn, rej_fn);
} else {
ant_value_t enqueue_result = ts_ctrl_enqueue(js, ctrl_obj, chunk);
if (is_err(enqueue_result)) {
ant_value_t err = ts_take_thrown_or(js, enqueue_result);
js_reject_promise(js, p, err);
return p;
}
js_resolve_promise(js, p, js_mkundef());
}
return p;
}
static ant_value_t ts_cancel_base_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ts_clear_cancel_state(ts_obj, p);
js_resolve_promise(js, p, js_mkundef());
return js_mkundef();
}
static ant_value_t ts_cancel_base_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t err = (nargs > 0) ? args[0] : js_mkundef();
ts_clear_cancel_state(ts_obj, p);
js_reject_promise(js, p, err);
return js_mkundef();
}
static ant_value_t ts_run_cancel_algorithm(ant_t *js, ant_value_t ts_obj, ant_value_t cancel_fn, ant_value_t reason, bool started_by_abort) {
ant_value_t existing = ts_cancel_promise(ts_obj);
if (vtype(existing) == T_PROMISE) return existing;
ant_value_t p = js_mkpromise(js);
promise_mark_handled(p);
ts_set_cancel_state(js, ts_obj, p, started_by_abort, is_callable(cancel_fn));
ts_ctrl_clear_algorithms(ts_controller(ts_obj));
ant_value_t result = js_mkundef();
if (is_callable(cancel_fn)) {
ant_value_t cancel_args[1] = { reason };
result = sv_vm_call(js->vm, js, cancel_fn, ts_ctrl_transformer(ts_controller(ts_obj)), cancel_args, 1, NULL, false);
}
if (is_err(result)) {
ant_value_t err = ts_take_thrown_or(js, result);
ts_clear_cancel_state(ts_obj, p);
js_reject_promise(js, p, err);
return p;
}
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, p);
js_set_slot(wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t res_fn = js_heavy_mkfun(js, ts_cancel_base_resolve, wrapper);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_cancel_base_reject, wrapper);
ts_chain_promise(js, result, res_fn, rej_fn);
return p;
}
static ant_value_t ts_source_cancel_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t reason = js_get_slot(wrapper, SLOT_AUX);
ant_value_t readable = ts_readable(ts_obj);
rs_stream_t *rs = rs_get_stream(readable);
ant_value_t settle_error = ts_cancel_settle_error(ts_obj);
if (is_object_type(settle_error)) {
js_reject_promise(js, p, settle_error);
return js_mkundef();
}
if (rs && rs->state == RS_STATE_ERRORED) {
js_reject_promise(js, p, rs_stream_error(readable));
return js_mkundef();
}
ant_value_t writable = ts_writable(ts_obj);
ws_stream_t *ws = ws_get_stream(writable);
if (ws && ws->state == WS_STATE_WRITABLE)
ts_error_writable_and_unblock_write(js, ts_obj, reason);
js_resolve_promise(js, p, js_mkundef());
return js_mkundef();
}
static ant_value_t ts_source_cancel_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t err = (nargs > 0) ? args[0] : js_mkundef();
ts_error_writable_and_unblock_write(js, ts_obj, err);
js_reject_promise(js, p, err);
return js_mkundef();
}
static ant_value_t ts_abort_cancel_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t reason = js_get_slot(wrapper, SLOT_AUX);
ant_value_t readable = ts_readable(ts_obj);
rs_stream_t *rs = rs_get_stream(readable);
if (rs && rs->state == RS_STATE_ERRORED) {
js_reject_promise(js, p, rs_stream_error(readable));
return js_mkundef();
}
if (ts_cancel_joined_abort(ts_obj)) js_set_slot_wb(js, ts_obj, SLOT_RS_SIZE, reason);
ts_error(js, ts_obj, reason);
if (ts_cancel_joined_abort(ts_obj)) js_reject_promise(js, p, reason);
else js_resolve_promise(js, p, js_mkundef());
return js_mkundef();
}
static ant_value_t ts_abort_cancel_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t err = (nargs > 0) ? args[0] : js_mkundef();
ts_error(js, ts_obj, err);
js_reject_promise(js, p, err);
return js_mkundef();
}
static ant_value_t ts_close_cancel_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t readable = ts_readable(ts_obj);
rs_stream_t *rs = rs_get_stream(readable);
ant_value_t settle_error = ts_cancel_settle_error(ts_obj);
if (is_object_type(settle_error)) {
js_reject_promise(js, p, settle_error);
return js_mkundef();
}
if (rs && rs->state == RS_STATE_ERRORED) {
js_reject_promise(js, p, rs_stream_error(readable));
return js_mkundef();
}
js_resolve_promise(js, p, js_mkundef());
return js_mkundef();
}
static ant_value_t ts_close_cancel_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t err = (nargs > 0) ? args[0] : js_mkundef();
js_reject_promise(js, p, err);
return js_mkundef();
}
static ant_value_t ts_sink_write_bp_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t ctrl_obj = js_get_slot(wrapper, SLOT_DATA);
ant_value_t chunk = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_CTOR);
ws_stream_t *ws = ws_get_stream(ts_writable(ts_obj));
if (ws && ws->state == WS_STATE_ERRORING) {
ant_value_t err = ts_writable_stored_error(ts_obj);
if (!is_object_type(err))
err = js_make_error_silent(js, JS_ERR_TYPE, "WritableStream is in erroring state");
ant_value_t fp = ts_ctrl_finish_promise(ctrl_obj);
if (vtype(fp) == T_PROMISE) js_reject_promise(js, fp, err);
return js_mkundef();
}
ant_value_t transform_p = ts_ctrl_perform_transform(js, ctrl_obj, chunk);
ant_value_t fp = ts_ctrl_finish_promise(ctrl_obj);
if (vtype(fp) == T_PROMISE) {
ant_value_t resolve_fn = js_heavy_mkfun(js, ts_transform_resolve, fp);
ant_value_t rej_wrapper = js_mkobj(js);
js_set_slot(rej_wrapper, SLOT_DATA, fp);
js_set_slot(rej_wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t reject_fn = js_heavy_mkfun(js, ts_transform_reject, rej_wrapper);
ts_chain_promise(js, transform_p, resolve_fn, reject_fn);
}
return js_mkundef();
}
static ant_value_t ts_sink_write(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef();
ant_value_t ctrl_obj = ts_controller(ts_obj);
ant_value_t finish_p = js_mkpromise(js);
promise_mark_handled(finish_p);
js_set_slot_wb(js, ctrl_obj, SLOT_RS_PULL, finish_p);
if (ts_get_backpressure(ts_obj)) {
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, ctrl_obj);
js_set_slot(wrapper, SLOT_ENTRIES, chunk);
js_set_slot(wrapper, SLOT_CTOR, ts_obj);
ant_value_t res_fn = js_heavy_mkfun(js, ts_sink_write_bp_resolve, wrapper);
ant_value_t rej_wrapper = js_mkobj(js);
js_set_slot(rej_wrapper, SLOT_DATA, finish_p);
js_set_slot(rej_wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_transform_reject, rej_wrapper);
ant_value_t bp = ts_bp_promise(ts_obj);
ts_chain_promise(js, bp, res_fn, rej_fn);
} else {
ant_value_t transform_p = ts_ctrl_perform_transform(js, ctrl_obj, chunk);
ant_value_t resolve_fn = js_heavy_mkfun(js, ts_transform_resolve, finish_p);
ant_value_t rej_wrapper = js_mkobj(js);
js_set_slot(rej_wrapper, SLOT_DATA, finish_p);
js_set_slot(rej_wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t reject_fn = js_heavy_mkfun(js, ts_transform_reject, rej_wrapper);
ts_chain_promise(js, transform_p, resolve_fn, reject_fn);
}
return finish_p;
}
static ant_value_t ts_sink_abort(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t ctrl_obj = ts_controller(ts_obj);
ant_value_t cancel_fn = ts_ctrl_cancel_fn(ctrl_obj);
ant_value_t reason = (nargs > 0) ? args[0] : js_mkundef();
bool joined_source_cancel = vtype(ts_cancel_promise(ts_obj)) == T_PROMISE && !ts_cancel_started_by_abort(ts_obj);
if (joined_source_cancel && ts_cancel_has_user_handler(ts_obj))
js_set_slot(ts_obj, SLOT_WS_WRITE, js_true);
ant_value_t p = js_mkpromise(js);
ant_value_t base = ts_run_cancel_algorithm(js, ts_obj, cancel_fn, reason, true);
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, p);
js_set_slot(wrapper, SLOT_ENTRIES, ts_obj);
js_set_slot(wrapper, SLOT_AUX, reason);
js_set_slot(wrapper, SLOT_CTOR, ts_cancel_started_by_abort(ts_obj) ? js_true : js_false);
ant_value_t res_fn = js_heavy_mkfun(js, ts_abort_cancel_resolve, wrapper);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_abort_cancel_reject, wrapper);
ts_chain_promise(js, base, res_fn, rej_fn);
return p;
}
static ant_value_t ts_sink_close_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t readable = ts_readable(ts_obj);
rs_stream_t *rs = rs_get_stream(readable);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
ts_set_flushing(ts_obj, false);
if (rs && rs->state == RS_STATE_READABLE) {
rs_controller_close(js, rs_ctrl);
js_resolve_promise(js, p, js_mkundef());
} else if (rs && rs->state == RS_STATE_CLOSED) {
js_resolve_promise(js, p, js_mkundef());
} else if (rs && rs->state == RS_STATE_ERRORED) {
js_reject_promise(js, p, rs_stream_error(readable));
} else {
js_reject_promise(js, p, js_make_error_silent(js, JS_ERR_TYPE, "TransformStream readable side is not in a readable state"));
}
return js_mkundef();
}
static ant_value_t ts_sink_close_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t p = js_get_slot(wrapper, SLOT_DATA);
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
ant_value_t e = (nargs > 0) ? args[0] : js_mkundef();
ts_set_flushing(ts_obj, false);
ts_error(js, ts_obj, e);
js_reject_promise(js, p, e);
return js_mkundef();
}
static ant_value_t ts_sink_close(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t ctrl_obj = ts_controller(ts_obj);
ant_value_t readable = ts_readable(ts_obj);
ant_value_t flush_fn = ts_ctrl_flush_fn(ctrl_obj);
ant_value_t p = js_mkpromise(js);
promise_mark_handled(p);
ant_value_t cancel_p = ts_cancel_promise(ts_obj);
if (vtype(cancel_p) == T_PROMISE) {
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, p);
js_set_slot(wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t res_fn = js_heavy_mkfun(js, ts_close_cancel_resolve, wrapper);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_close_cancel_reject, wrapper);
ts_chain_promise(js, cancel_p, res_fn, rej_fn);
return p;
}
ts_ctrl_clear_algorithms(ctrl_obj);
ts_set_flushing(ts_obj, true);
if (is_callable(flush_fn)) {
ant_value_t flush_args[1] = { ctrl_obj };
ant_value_t result = sv_vm_call(js->vm, js, flush_fn, ts_ctrl_transformer(ctrl_obj), flush_args, 1, NULL, false);
if (is_err(result)) {
ant_value_t err = ts_take_thrown_or(js, result);
ts_error(js, ts_obj, err);
ts_set_flushing(ts_obj, false);
js_reject_promise(js, p, err);
return p;
}
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, p);
js_set_slot(wrapper, SLOT_ENTRIES, ts_obj);
ant_value_t res_fn = js_heavy_mkfun(js, ts_sink_close_resolve, wrapper);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_sink_close_reject, wrapper);
ts_chain_promise(js, result, res_fn, rej_fn);
} else {
rs_stream_t *rs = rs_get_stream(readable);
if (rs && rs->state == RS_STATE_READABLE) {
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_controller_t *rc = rs_get_controller(rs_ctrl);
if (rc) rc->defer_close = true;
rs_controller_close(js, rs_ctrl);
if (rc) rc->defer_close = false;
}
ts_set_flushing(ts_obj, false);
js_resolve_promise(js, p, js_mkundef());
}
return p;
}
static ant_value_t ts_source_pull_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t p = js_get_slot(js->current_func, SLOT_DATA);
js_resolve_promise(js, p, js_mkundef());
return js_mkundef();
}
static ant_value_t ts_source_pull(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
if (ts_get_backpressure(ts_obj)) {
ts_set_backpressure(js, ts_obj, false);
ant_value_t p = js_mkpromise(js);
js_resolve_promise(js, p, js_mkundef());
return p;
}
ant_value_t p = js_mkpromise(js);
js_resolve_promise(js, p, js_mkundef());
return p;
}
static ant_value_t ts_source_cancel(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t ctrl_obj = ts_controller(ts_obj);
ant_value_t cancel_fn = ts_ctrl_cancel_fn(ctrl_obj);
ant_value_t reason = (nargs > 0) ? args[0] : js_mkundef();
if (ts_is_flushing(ts_obj)) {
ant_value_t p = js_mkpromise(js);
js_resolve_promise(js, p, js_mkundef());
return p;
}
ant_value_t p = js_mkpromise(js);
ant_value_t base = ts_run_cancel_algorithm(js, ts_obj, cancel_fn, reason, false);
ant_value_t wrapper = js_mkobj(js);
js_set_slot(wrapper, SLOT_DATA, p);
js_set_slot(wrapper, SLOT_ENTRIES, ts_obj);
js_set_slot(wrapper, SLOT_AUX, reason);
js_set_slot(wrapper, SLOT_CTOR, ts_cancel_started_by_abort(ts_obj) ? js_true : js_false);
ant_value_t res_fn = js_heavy_mkfun(js, ts_source_cancel_resolve, wrapper);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_source_cancel_reject, wrapper);
ts_chain_promise(js, base, res_fn, rej_fn);
return p;
}
static ant_value_t js_ts_ctrl_get_desired_size(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = ts_ctrl_stream(js->this_val);
ant_value_t readable = ts_readable(ts_obj);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_controller_t *rc = rs_get_controller(rs_ctrl);
rs_stream_t *rs = rs_get_stream(readable);
if (!rc || !rs) return js_mknull();
if (rs->state == RS_STATE_ERRORED) return js_mknull();
if (rs->state == RS_STATE_CLOSED) return js_mknum(0);
return js_mknum(rc->strategy_hwm - rc->queue_total_size);
}
static ant_value_t js_ts_ctrl_enqueue(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = ts_ctrl_stream(js->this_val);
ant_value_t readable = ts_readable(ts_obj);
rs_stream_t *rs = rs_get_stream(readable);
if (!rs || rs->state != RS_STATE_READABLE)
return js_mkerr_typed(js, JS_ERR_TYPE, "Readable side is not in a readable state");
ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef();
return ts_ctrl_enqueue(js, js->this_val, chunk);
}
static ant_value_t js_ts_ctrl_error(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t e = (nargs > 0) ? args[0] : js_mkundef();
ts_ctrl_error(js, js->this_val, e);
return js_mkundef();
}
static ant_value_t js_ts_ctrl_terminate(ant_t *js, ant_value_t *args, int nargs) {
ts_ctrl_terminate(js, js->this_val);
return js_mkundef();
}
static ant_value_t js_ts_get_readable(ant_t *js, ant_value_t *args, int nargs) {
if (!ts_is_stream(js->this_val)) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStream");
return ts_readable(js->this_val);
}
static ant_value_t js_ts_get_writable(ant_t *js, ant_value_t *args, int nargs) {
if (!ts_is_stream(js->this_val)) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStream");
return ts_writable(js->this_val);
}
static ant_value_t ts_start_resolve(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t writable = ts_writable(ts_obj);
ant_value_t ws_ctrl = ws_stream_controller(writable);
ws_controller_t *wc = ws_get_controller(ws_ctrl);
if (wc) wc->started = true;
ws_default_controller_advance_queue_if_needed(js, ws_ctrl);
ant_value_t readable = ts_readable(ts_obj);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_controller_t *rc = rs_get_controller(rs_ctrl);
if (rc) {
rc->started = true;
rc->pulling = false;
rc->pull_again = false;
rs_default_controller_call_pull_if_needed(js, rs_ctrl);
}
return js_mkundef();
}
static ant_value_t ts_start_reject(ant_t *js, ant_value_t *args, int nargs) {
ant_value_t ts_obj = js_get_slot(js->current_func, SLOT_DATA);
ant_value_t e = (nargs > 0) ? args[0] : js_mkundef();
ant_value_t writable = ts_writable(ts_obj);
ant_value_t ws_ctrl = ws_stream_controller(writable);
ws_controller_t *wc = ws_get_controller(ws_ctrl);
if (wc) wc->started = true;
ant_value_t readable = ts_readable(ts_obj);
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
rs_controller_t *rc = rs_get_controller(rs_ctrl);
if (rc) rc->started = true;
readable_stream_error(js, readable, e);
ws_stream_t *ws = ws_get_stream(writable);
if (ws && ws->state == WS_STATE_WRITABLE)
ws_default_controller_error(js, ws_ctrl, e);
else if (ws && ws->state == WS_STATE_ERRORING)
writable_stream_finish_erroring(js, writable);
return js_mkundef();
}
ant_value_t js_ts_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, "TransformStream constructor requires 'new'");
ant_value_t transformer = js_mkundef();
if (nargs > 0 && !is_undefined(args[0]))
transformer = args[0];
if (is_object_type(transformer)) {
ant_value_t rt_val = js_getprop_fallback(js, transformer, "readableType");
if (!is_undefined(rt_val))
return js_mkerr_typed(js, JS_ERR_RANGE, "readableType is not supported");
ant_value_t wt_val = js_getprop_fallback(js, transformer, "writableType");
if (!is_undefined(wt_val))
return js_mkerr_typed(js, JS_ERR_RANGE, "writableType is not supported");
}
ant_value_t writable_strategy = js_mkundef();
if (nargs > 1 && !is_undefined(args[1]) && !is_null(args[1]))
writable_strategy = args[1];
ant_value_t readable_strategy = js_mkundef();
if (nargs > 2 && !is_undefined(args[2]) && !is_null(args[2]))
readable_strategy = args[2];
double writable_hwm = 1;
ant_value_t writable_size_fn = js_mkundef();
if (is_object_type(writable_strategy)) {
ant_value_t hwm_val = js_getprop_fallback(js, writable_strategy, "highWaterMark");
if (is_err(hwm_val)) return hwm_val;
if (!is_undefined(hwm_val)) {
writable_hwm = js_to_number(js, hwm_val);
if (writable_hwm != writable_hwm || writable_hwm < 0)
return js_mkerr_typed(js, JS_ERR_RANGE, "Invalid highWaterMark");
}
ant_value_t s = js_getprop_fallback(js, writable_strategy, "size");
if (is_err(s)) return s;
if (!is_undefined(s)) {
if (!is_callable(s)) return js_mkerr_typed(js, JS_ERR_TYPE, "size must be a function");
writable_size_fn = s;
}
}
double readable_hwm = 0;
ant_value_t readable_size_fn = js_mkundef();
if (is_object_type(readable_strategy)) {
ant_value_t hwm_val = js_getprop_fallback(js, readable_strategy, "highWaterMark");
if (is_err(hwm_val)) return hwm_val;
if (!is_undefined(hwm_val)) {
readable_hwm = js_to_number(js, hwm_val);
if (readable_hwm != readable_hwm || readable_hwm < 0)
return js_mkerr_typed(js, JS_ERR_RANGE, "Invalid highWaterMark");
}
ant_value_t s = js_getprop_fallback(js, readable_strategy, "size");
if (is_err(s)) return s;
if (!is_undefined(s)) {
if (!is_callable(s)) return js_mkerr_typed(js, JS_ERR_TYPE, "size must be a function");
readable_size_fn = s;
}
}
ant_value_t transform_fn = js_mkundef();
ant_value_t flush_fn = js_mkundef();
ant_value_t cancel_fn = js_mkundef();
ant_value_t start_fn = js_mkundef();
if (is_object_type(transformer)) {
ant_value_t tv = js_getprop_fallback(js, transformer, "transform");
if (is_err(tv)) return tv;
if (!is_undefined(tv)) {
if (!is_callable(tv)) return js_mkerr_typed(js, JS_ERR_TYPE, "transform must be a function");
transform_fn = tv;
}
ant_value_t fv = js_getprop_fallback(js, transformer, "flush");
if (is_err(fv)) return fv;
if (!is_undefined(fv)) {
if (!is_callable(fv)) return js_mkerr_typed(js, JS_ERR_TYPE, "flush must be a function");
flush_fn = fv;
}
ant_value_t cv = js_getprop_fallback(js, transformer, "cancel");
if (is_err(cv)) return cv;
if (!is_undefined(cv)) {
if (!is_callable(cv)) return js_mkerr_typed(js, JS_ERR_TYPE, "cancel must be a function");
cancel_fn = cv;
}
ant_value_t sv = js_getprop_fallback(js, transformer, "start");
if (is_err(sv)) return sv;
if (!is_undefined(sv)) {
if (!is_callable(sv)) return js_mkerr_typed(js, JS_ERR_TYPE, "start must be a function");
start_fn = sv;
}
}
ant_value_t ts_obj = js_mkobj(js);
ant_value_t proto = js_instance_proto_from_new_target(js, g_ts_proto);
if (is_object_type(proto)) js_set_proto_init(ts_obj, proto);
js_set_slot(ts_obj, SLOT_BRAND, js_mknum(BRAND_TRANSFORM_STREAM));
js_set_slot(ts_obj, SLOT_DATA, js_mknum(0));
ant_value_t ctrl_obj = js_mkobj(js);
js_set_proto_init(ctrl_obj, g_ts_ctrl_proto);
js_set_slot(ctrl_obj, SLOT_BRAND, js_mknum(BRAND_TRANSFORM_STREAM_CONTROLLER));
js_set_slot(ctrl_obj, SLOT_DATA, ts_obj);
js_set_slot(ctrl_obj, SLOT_ENTRIES, transform_fn);
js_set_slot(ctrl_obj, SLOT_CTOR, flush_fn);
js_set_slot(ctrl_obj, SLOT_AUX, cancel_fn);
js_set_slot(ctrl_obj, SLOT_SETTLED, transformer);
js_set_slot(ctrl_obj, SLOT_RS_PULL, js_mkundef());
js_set_slot(ts_obj, SLOT_DEFAULT, ctrl_obj);
js_set_slot(ts_obj, SLOT_RS_CANCEL, js_mkundef());
js_set_slot(ts_obj, SLOT_WS_ABORT, js_false);
js_set_slot(ts_obj, SLOT_WS_CLOSE, js_false);
js_set_slot(ts_obj, SLOT_RS_SIZE, js_mkundef());
js_set_slot(ts_obj, SLOT_WS_WRITE, js_false);
js_set_slot(ts_obj, SLOT_WS_SIGNAL, js_false);
ant_value_t sink_write = js_heavy_mkfun(js, ts_sink_write, ts_obj);
ant_value_t sink_abort = js_heavy_mkfun(js, ts_sink_abort, ts_obj);
ant_value_t sink_close = js_heavy_mkfun(js, ts_sink_close, ts_obj);
ant_value_t source_pull = js_heavy_mkfun(js, ts_source_pull, ts_obj);
ant_value_t source_cancel = js_heavy_mkfun(js, ts_source_cancel, ts_obj);
rs_stream_t *rst = calloc(1, sizeof(rs_stream_t));
if (!rst) return js_mkerr(js, "out of memory");
rst->state = RS_STATE_READABLE;
ant_value_t rs_obj = js_mkobj(js);
js_set_proto_init(rs_obj, g_rs_proto);
js_set_slot(rs_obj, SLOT_BRAND, js_mknum(BRAND_READABLE_STREAM));
js_set_slot(rs_obj, SLOT_DATA, ANT_PTR(rst));
js_set_finalizer(rs_obj, ts_rs_finalize);
rs_controller_t *rcc = calloc(1, sizeof(rs_controller_t));
if (!rcc) { free(rst); return js_mkerr(js, "out of memory"); }
rcc->strategy_hwm = readable_hwm;
ant_value_t rs_ctrl_obj = js_mkobj(js);
js_set_proto_init(rs_ctrl_obj, g_controller_proto);
js_set_slot(rs_ctrl_obj, SLOT_BRAND, js_mknum(BRAND_READABLE_STREAM_CONTROLLER));
js_set_slot(rs_ctrl_obj, SLOT_DATA, ANT_PTR(rcc));
js_set_slot(rs_ctrl_obj, SLOT_ENTRIES, rs_obj);
js_set_slot(rs_ctrl_obj, SLOT_RS_PULL, source_pull);
js_set_slot(rs_ctrl_obj, SLOT_RS_CANCEL, source_cancel);
js_set_slot(rs_ctrl_obj, SLOT_RS_SIZE, readable_size_fn);
js_set_slot(rs_ctrl_obj, SLOT_AUX, js_mkarr(js));
js_set_finalizer(rs_ctrl_obj, ts_rs_ctrl_finalize);
js_set_slot(rs_obj, SLOT_ENTRIES, rs_ctrl_obj);
js_set_slot(ts_obj, SLOT_ENTRIES, rs_obj);
ws_stream_t *wst = calloc(1, sizeof(ws_stream_t));
if (!wst) return js_mkerr(js, "out of memory");
wst->state = WS_STATE_WRITABLE;
ant_value_t ws_obj = js_mkobj(js);
js_set_proto_init(ws_obj, g_ws_proto);
js_set_slot(ws_obj, SLOT_BRAND, js_mknum(BRAND_WRITABLE_STREAM));
js_set_slot(ws_obj, SLOT_DATA, ANT_PTR(wst));
js_set_slot(ws_obj, SLOT_SETTLED, js_mkarr(js));
js_set_finalizer(ws_obj, ts_ws_finalize);
js_set_slot(ts_obj, SLOT_CTOR, ws_obj);
ant_value_t bp_promise = js_mkpromise(js);
js_set_slot_wb(js, ts_obj, SLOT_AUX, bp_promise);
ts_set_backpressure(js, ts_obj, true);
ws_controller_t *wc = calloc(1, sizeof(ws_controller_t));
if (!wc) { free(wst); return js_mkerr(js, "out of memory"); }
wc->strategy_hwm = writable_hwm;
ant_value_t ws_ctrl_obj = js_mkobj(js);
js_set_proto_init(ws_ctrl_obj, g_ws_controller_proto);
js_set_slot(ws_ctrl_obj, SLOT_BRAND, js_mknum(BRAND_WRITABLE_STREAM_CONTROLLER));
js_set_slot(ws_ctrl_obj, SLOT_DATA, ANT_PTR(wc));
js_set_slot(ws_ctrl_obj, SLOT_ENTRIES, ws_obj);
js_set_slot(ws_ctrl_obj, SLOT_WS_WRITE, sink_write);
js_set_slot(ws_ctrl_obj, SLOT_WS_CLOSE, sink_close);
js_set_slot(ws_ctrl_obj, SLOT_WS_ABORT, sink_abort);
js_set_slot(ws_ctrl_obj, SLOT_RS_SIZE, writable_size_fn);
js_set_slot(ws_ctrl_obj, SLOT_CTOR, js_mkundef());
js_set_slot(ws_ctrl_obj, SLOT_AUX, js_mkarr(js));
js_set_finalizer(ws_ctrl_obj, ts_ws_ctrl_finalize);
js_set_slot(ws_obj, SLOT_ENTRIES, ws_ctrl_obj);
if (is_callable(start_fn)) {
ant_value_t start_args[1] = { ctrl_obj };
ant_value_t start_result = sv_vm_call(js->vm, js, start_fn, transformer, start_args, 1, NULL, false);
if (is_err(start_result)) { return start_result; }
if (vtype(start_result) == T_PROMISE) {
ant_value_t resolve_fn = js_heavy_mkfun(js, ts_start_resolve, ts_obj);
ant_value_t reject_fn = js_heavy_mkfun(js, ts_start_reject, ts_obj);
js_promise_then(js, start_result, resolve_fn, reject_fn);
}
if (vtype(start_result) != T_PROMISE) {
ant_value_t resolved = js_mkpromise(js);
js_resolve_promise(js, resolved, js_mkundef());
ant_value_t res_fn = js_heavy_mkfun(js, ts_start_resolve, ts_obj);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_start_reject, ts_obj);
js_promise_then(js, resolved, res_fn, rej_fn);
}
} else {
ant_value_t resolved = js_mkpromise(js);
js_resolve_promise(js, resolved, js_mkundef());
ant_value_t res_fn = js_heavy_mkfun(js, ts_start_resolve, ts_obj);
ant_value_t rej_fn = js_heavy_mkfun(js, ts_start_reject, ts_obj);
js_promise_then(js, resolved, res_fn, rej_fn);
}
return ts_obj;
}
static ant_value_t js_ts_ctrl_ctor(ant_t *js, ant_value_t *args, int nargs) {
return js_mkerr_typed(js, JS_ERR_TYPE, "TransformStreamDefaultController cannot be constructed directly");
}
void init_transform_stream_module(void) {
ant_t *js = rt->js;
ant_value_t g = js_glob(js);
g_ts_ctrl_proto = js_mkobj(js);
js_set_getter_desc(js, g_ts_ctrl_proto, "desiredSize", 11, js_mkfun(js_ts_ctrl_get_desired_size), JS_DESC_C);
js_set(js, g_ts_ctrl_proto, "enqueue", js_mkfun(js_ts_ctrl_enqueue));
js_set_descriptor(js, g_ts_ctrl_proto, "enqueue", 7, JS_DESC_W | JS_DESC_C);
js_set(js, g_ts_ctrl_proto, "error", js_mkfun(js_ts_ctrl_error));
js_set_descriptor(js, g_ts_ctrl_proto, "error", 5, JS_DESC_W | JS_DESC_C);
js_set(js, g_ts_ctrl_proto, "terminate", js_mkfun(js_ts_ctrl_terminate));
js_set_descriptor(js, g_ts_ctrl_proto, "terminate", 9, JS_DESC_W | JS_DESC_C);
js_set_sym(js, g_ts_ctrl_proto, get_toStringTag_sym(), js_mkstr(js, "TransformStreamDefaultController", 32));
ant_value_t ctrl_ctor = js_make_ctor(js, js_ts_ctrl_ctor, g_ts_ctrl_proto, "TransformStreamDefaultController", 32);
js_set(js, g, "TransformStreamDefaultController", ctrl_ctor);
js_set_descriptor(js, g, "TransformStreamDefaultController", 32, JS_DESC_W | JS_DESC_C);
g_ts_proto = js_mkobj(js);
js_set_getter_desc(js, g_ts_proto, "readable", 8, js_mkfun(js_ts_get_readable), JS_DESC_C);
js_set_getter_desc(js, g_ts_proto, "writable", 8, js_mkfun(js_ts_get_writable), JS_DESC_C);
js_set_sym(js, g_ts_proto, get_toStringTag_sym(), js_mkstr(js, "TransformStream", 15));
ant_value_t ts_ctor = js_make_ctor(js, js_ts_ctor, g_ts_proto, "TransformStream", 15);
js_set(js, g, "TransformStream", ts_ctor);
js_set_descriptor(js, g, "TransformStream", 15, JS_DESC_W | JS_DESC_C);
}
void gc_mark_transform_streams(ant_t *js, void (*mark)(ant_t *, ant_value_t)) {
mark(js, g_ts_proto);
mark(js, g_ts_ctrl_proto);
}

Owner Packages

  • No Owners