Something went wrong. Try again.
javascript for 🐜's, a tiny runtime with big ambitions antjs.org
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522#include <stdlib.h>#include <string.h>#include <strings.h>#include <ctype.h>#include <stdio.h>
#include "ant.h"#include "errors.h"#include "runtime.h"#include "internal.h"#include "common.h"#include "descriptors.h"
#include "modules/blob.h"#include "modules/buffer.h"#include "modules/assert.h"#include "modules/abort.h"#include "modules/formdata.h"#include "modules/headers.h"#include "modules/multipart.h"#include "modules/request.h"#include "modules/symbol.h"#include "modules/url.h"#include "modules/json.h"#include "streams/pipes.h"#include "streams/readable.h"
ant_value_t g_request_proto = 0;
static request_data_t *get_data(ant_value_t obj) { ant_value_t slot = js_get_slot(obj, SLOT_DATA); if (vtype(slot) != T_NUM) return NULL; return (request_data_t *)(uintptr_t)(size_t)js_getnum(slot);}
request_data_t *request_get_data(ant_value_t obj) { return get_data(obj);}
ant_value_t request_get_headers(ant_value_t obj) { return js_get_slot(obj, SLOT_REQUEST_HEADERS);}
ant_value_t request_get_signal(ant_t *js, ant_value_t obj) { ant_value_t signal = js_get_slot(obj, SLOT_REQUEST_SIGNAL);
if (vtype(signal) != T_UNDEF) return signal; signal = abort_signal_create_dependent(js, js_mkundef()); if (is_err(signal)) return signal; ant_value_t abort_reason = js_get_slot(obj, SLOT_REQUEST_ABORT_REASON); if (vtype(abort_reason) != T_UNDEF) signal_do_abort(js, signal, abort_reason); js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, signal); return signal;}
static void data_free(request_data_t *d) { if (!d) return; free(d->method); url_state_clear(&d->url); free(d->referrer); free(d->referrer_policy); free(d->mode); free(d->credentials); free(d->cache); free(d->redirect); free(d->integrity); free(d->body_data); free(d->body_type); free(d);}
static request_data_t *data_new_with(const char *method, const char *mode) { request_data_t *d = calloc(1, sizeof(request_data_t)); if (!d) return NULL;
d->method = strdup(method ? method : "GET"); d->referrer = strdup("client"); d->referrer_policy = strdup(""); d->mode = strdup(mode); d->credentials = strdup("same-origin"); d->cache = strdup("default"); d->redirect = strdup("follow"); d->integrity = strdup(""); if (!d->method || !d->referrer || !d->referrer_policy || !d->mode || !d->credentials || !d->cache || !d->redirect || !d->integrity ) { data_free(d); return NULL; }
return d;}
static request_data_t *data_new(void) { return data_new_with("GET", "cors"); }static request_data_t *data_new_server(const char *method) { return data_new_with(method, "same-origin"); }
static ant_value_t request_create_object(ant_t *js, request_data_t *req, ant_value_t headers_obj, bool create_signal) { ant_value_t obj = js_mkobj(js); ant_value_t hdrs = is_object_type(headers_obj) ? headers_obj : headers_create_empty(js);
js_set_proto_init(obj, g_request_proto); js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST)); js_set_slot(obj, SLOT_DATA, ANT_PTR(req));
headers_set_guard(hdrs, strcmp(req->mode, "no-cors") == 0 ? HEADERS_GUARD_REQUEST_NO_CORS : HEADERS_GUARD_REQUEST );
headers_apply_guard(hdrs); js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, hdrs); js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef()); js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, create_signal ? abort_signal_create_dependent(js, js_mkundef()) : js_mkundef() ); return obj;}
static char *request_build_server_base_url(const char *host, const char *server_hostname, int server_port) { const char *authority = (host && host[0]) ? host : server_hostname; size_t authority_len = authority ? strlen(authority) : 0; bool include_port = (!host || !host[0]) && server_port > 0 && server_port != 80; size_t cap = sizeof("http://") - 1 + authority_len + 1 + 16 + 1; char *base = malloc(cap); int written = 0;
if (!base) return NULL; if (include_port) written = snprintf(base, cap, "http://%s:%d/", authority ? authority : "", server_port); else written = snprintf(base, cap, "http://%s/", authority ? authority : ""); if (written < 0 || (size_t)written >= cap) { free(base); return NULL; }
return base;}
static int request_parse_server_url( const char *target, bool absolute_target, const char *host, const char *server_hostname, int server_port, url_state_t *out) { char *base = NULL; int rc = 0;
if (absolute_target) return parse_url_to_state(target, NULL, out);
base = request_build_server_base_url(host, server_hostname, server_port); if (!base) return -1; rc = parse_url_to_state(target, base, out); free(base); return rc;}
static request_data_t *data_dup(const request_data_t *src) { request_data_t *d = calloc(1, sizeof(request_data_t)); if (!d) return NULL;
#define DUP_STR(f) do { d->f = src->f ? strdup(src->f) : NULL; } while(0) DUP_STR(method); DUP_STR(referrer); DUP_STR(referrer_policy); DUP_STR(mode); DUP_STR(credentials); DUP_STR(cache); DUP_STR(redirect); DUP_STR(integrity); DUP_STR(body_type);#undef DUP_STR url_state_t *su = (url_state_t *)&src->url; url_state_t *du = &d->url;#define DUP_US(f) do { du->f = su->f ? strdup(su->f) : NULL; } while(0) DUP_US(protocol); DUP_US(username); DUP_US(password); DUP_US(hostname); DUP_US(port); DUP_US(pathname); DUP_US(search); DUP_US(hash);#undef DUP_US d->keepalive = src->keepalive; d->reload_navigation = src->reload_navigation; d->history_navigation = src->history_navigation; d->has_body = src->has_body; d->body_is_stream = src->body_is_stream; d->body_used = src->body_used; d->body_size = src->body_size;
if (src->body_data && src->body_size > 0) { d->body_data = malloc(src->body_size); if (!d->body_data) { data_free(d); return NULL; } memcpy(d->body_data, src->body_data, src->body_size); }
return d;}
static bool is_token_char(unsigned char c) { if (c == 0 || c > 127) return false; static const char *delimiters = "(),/:;<=>?@[\\]{}\""; return c > 32 && !strchr(delimiters, (char)c);}
static bool is_valid_method(const char *m) { if (!m || !*m) return false; for (const unsigned char *p = (const unsigned char *)m; *p; p++) if (!is_token_char(*p)) return false; return true;}
static bool is_forbidden_method(const char *m) { return strcasecmp(m, "CONNECT") == 0 || strcasecmp(m, "TRACE") == 0 || strcasecmp(m, "TRACK") == 0;}
static bool is_cors_safelisted_method(const char *m) { return strcasecmp(m, "GET") == 0 || strcasecmp(m, "HEAD") == 0 || strcasecmp(m, "POST") == 0;}
static void normalize_method(char *m) { static const char *norm[] = { "DELETE","GET","HEAD","OPTIONS","POST","PUT" }; for (int i = 0; i < 6; i++) { if (strcasecmp(m, norm[i]) == 0) { strcpy(m, norm[i]); return; }}}
static ant_value_t request_rejection_reason(ant_t *js, ant_value_t value) { if (!is_err(value)) return value; ant_value_t reason = js->thrown_exists ? js->thrown_value : value; js->thrown_exists = false; js->thrown_value = js_mkundef(); js->thrown_stack = js_mkundef(); return reason;}
static const char *request_effective_body_type(ant_t *js, ant_value_t req_obj, request_data_t *d) { ant_value_t headers = js_get_slot(req_obj, SLOT_REQUEST_HEADERS); if (!headers_is_headers(headers)) return d ? d->body_type : NULL; ant_value_t ct = headers_get_value(js, headers, "content-type"); if (vtype(ct) == T_STR) return js_getstr(js, ct, NULL); return d ? d->body_type : NULL;}
static bool copy_body_bytes( ant_t *js, const uint8_t *src, size_t src_len, uint8_t **out_data, size_t *out_size, ant_value_t *err_out) { uint8_t *buf = NULL;
*out_data = NULL; *out_size = 0; if (src_len == 0) return true;
buf = malloc(src_len); if (!buf) { *err_out = js_mkerr(js, "out of memory"); return false; }
memcpy(buf, src, src_len); *out_data = buf; *out_size = src_len; return true;}
static bool extract_buffer_source_body( ant_t *js, ant_value_t body_val, uint8_t **out_data, size_t *out_size, ant_value_t *err_out) { const uint8_t *src = NULL; size_t src_len = 0;
if (!(( vtype(body_val) == T_TYPEDARRAY || vtype(body_val) == T_OBJ) && buffer_source_get_bytes(js, body_val, &src, &src_len)) ) return false;
return copy_body_bytes(js, src, src_len, out_data, out_size, err_out);}
static bool extract_stream_body( ant_t *js, ant_value_t body_val, ant_value_t *out_stream, ant_value_t *err_out) { if (!rs_is_stream(body_val)) return false; if (rs_stream_unusable(body_val)) { *err_out = js_mkerr_typed(js, JS_ERR_TYPE, "body stream is disturbed or locked"); return false; }
*out_stream = body_val; return true;}
static bool extract_blob_body( ant_t *js, ant_value_t body_val, uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *err_out) { blob_data_t *bd = blob_is_blob(js, body_val) ? blob_get_data(body_val) : NULL; if (!bd) return false;
if (!copy_body_bytes(js, bd->data, bd->size, out_data, out_size, err_out)) return false; if (bd->type && bd->type[0]) *out_type = strdup(bd->type); return true;}
static bool extract_urlsearchparams_body( ant_t *js, ant_value_t body_val, uint8_t **out_data, size_t *out_size, char **out_type) { char *serialized = NULL; if (!usp_is_urlsearchparams(js, body_val)) return false;
serialized = usp_serialize(js, body_val); if (serialized) { *out_data = (uint8_t *)serialized; *out_size = strlen(serialized); *out_type = strdup("application/x-www-form-urlencoded;charset=UTF-8"); } return true;}
static bool extract_formdata_body( ant_t *js, ant_value_t body_val, uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *err_out) { char *boundary = NULL; char *content_type = NULL; size_t mp_size = 0; uint8_t *mp = NULL;
if (!formdata_is_formdata(js, body_val)) return false; mp = formdata_serialize_multipart(js, body_val, &mp_size, &boundary); if (!mp) { *err_out = js_mkerr(js, "out of memory"); return false; }
if (mp_size > 0) *out_data = mp; else free(mp);
*out_size = mp_size; if (boundary) { size_t ct_len = snprintf(NULL, 0, "multipart/form-data; boundary=%s", boundary); content_type = malloc(ct_len + 1); if (!content_type) { free(boundary); if (mp_size > 0) free(mp); *out_data = NULL; *out_size = 0; *err_out = js_mkerr(js, "out of memory"); return false; } snprintf(content_type, ct_len + 1, "multipart/form-data; boundary=%s", boundary); free(boundary); *out_type = content_type; }
return true;}
static bool extract_string_body( ant_t *js, ant_value_t body_val, uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *err_out) { size_t len = 0; const char *s = NULL;
if (vtype(body_val) != T_STR) { body_val = js_tostring_val(js, body_val); if (is_err(body_val)) { *err_out = body_val; return false; }}
s = js_getstr(js, body_val, &len); if (!copy_body_bytes(js, (const uint8_t *)s, len, out_data, out_size, err_out)) return false; *out_type = strdup("text/plain;charset=UTF-8"); return true;}
static bool extract_body( ant_t *js, ant_value_t body_val, uint8_t **out_data, size_t *out_size, char **out_type, ant_value_t *out_stream, ant_value_t *err_out) { *out_data = NULL; *out_size = 0; *out_type = NULL; *out_stream = js_mkundef(); *err_out = js_mkundef();
if (vtype(body_val) == T_NULL || vtype(body_val) == T_UNDEF) return true; if (extract_buffer_source_body(js, body_val, out_data, out_size, err_out)) return true; if (vtype(body_val) == T_OBJ && rs_is_stream(body_val)) return extract_stream_body(js, body_val, out_stream, err_out); if (vtype(body_val) == T_OBJ && extract_blob_body(js, body_val, out_data, out_size, out_type, err_out)) return true; if (vtype(body_val) == T_OBJ && extract_urlsearchparams_body(js, body_val, out_data, out_size, out_type)) return true; if (vtype(body_val) == T_OBJ && extract_formdata_body(js, body_val, out_data, out_size, out_type, err_out)) return true; return extract_string_body(js, body_val, out_data, out_size, out_type, err_out);}
enum { BODY_TEXT = 0, BODY_JSON, BODY_ARRAYBUFFER, BODY_BLOB, BODY_BYTES, BODY_FORMDATA};
static void resolve_body_promise( ant_t *js, ant_value_t promise, const uint8_t *data, size_t size, const char *body_type, int mode, bool has_body) { switch (mode) { case BODY_TEXT: { ant_value_t str = (data && size > 0) ? js_mkstr(js, (const char *)data, size) : js_mkstr(js, "", 0); js_resolve_promise(js, promise, str); break; } case BODY_JSON: { ant_value_t str = (data && size > 0) ? js_mkstr(js, (const char *)data, size) : js_mkstr(js, "", 0); ant_value_t parsed = json_parse_value(js, str); if (is_err(parsed)) js_reject_promise(js, promise, request_rejection_reason(js, parsed)); else js_resolve_promise(js, promise, parsed); break; } case BODY_ARRAYBUFFER: { ArrayBufferData *ab = create_array_buffer_data(size); if (!ab) { js_reject_promise(js, promise, js_mkerr(js, "out of memory")); break; } if (data && size > 0) memcpy(ab->data, data, size); js_resolve_promise(js, promise, create_arraybuffer_obj(js, ab)); break; } case BODY_BLOB: { const char *type = body_type ? body_type : ""; js_resolve_promise(js, promise, blob_create(js, data, size, type)); break; } case BODY_BYTES: { ArrayBufferData *ab = create_array_buffer_data(size); if (!ab) { js_reject_promise(js, promise, js_mkerr(js, "out of memory")); break; } if (data && size > 0) memcpy(ab->data, data, size); js_resolve_promise(js, promise, create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, size, "Uint8Array")); break; } case BODY_FORMDATA: { ant_value_t fd = formdata_parse_body(js, data, size, body_type, has_body); if (is_err(fd)) js_reject_promise(js, promise, request_rejection_reason(js, fd)); else js_resolve_promise(js, promise, fd); break; }}}
static uint8_t *concat_chunks(ant_t *js, ant_value_t chunks, size_t *out_size) { ant_offset_t n = js_arr_len(js, chunks); size_t total = 0;
for (ant_offset_t i = 0; i < n; i++) { ant_value_t chunk = js_arr_get(js, chunks, i); if (vtype(chunk) == T_TYPEDARRAY) { TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(chunk); if (ta && ta->buffer && !ta->buffer->is_detached) total += ta->byte_length; }}
uint8_t *buf = total > 0 ? malloc(total) : NULL; if (total > 0 && !buf) return NULL;
size_t pos = 0; for (ant_offset_t i = 0; i < n; i++) { ant_value_t chunk = js_arr_get(js, chunks, i); if (vtype(chunk) == T_TYPEDARRAY) { TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(chunk); if (ta && ta->buffer && !ta->buffer->is_detached && ta->byte_length > 0) { memcpy(buf + pos, ta->buffer->data + ta->byte_offset, ta->byte_length); pos += ta->byte_length; }}}
*out_size = pos; return buf;}
static ant_value_t stream_body_read(ant_t *js, ant_value_t *args, int nargs);
static ant_value_t stream_body_rejected(ant_t *js, ant_value_t *args, int nargs) { ant_value_t state = js_get_slot(js->current_func, SLOT_DATA); ant_value_t promise = js_get(js, state, "promise"); ant_value_t reason = (nargs > 0) ? args[0] : js_mkundef(); js_reject_promise(js, promise, reason); return js_mkundef();}
static void stream_schedule_next_read(ant_t *js, ant_value_t state, ant_value_t read_fn, ant_value_t reader) { ant_value_t next_p = rs_default_reader_read(js, reader); ant_value_t fulfill = js_heavy_mkfun(js, stream_body_read, state); ant_value_t reject = js_heavy_mkfun(js, stream_body_rejected, state); ant_value_t then_result = js_promise_then(js, next_p, fulfill, reject); promise_mark_handled(then_result);}
static ant_value_t stream_body_read(ant_t *js, ant_value_t *args, int nargs) { ant_value_t state = js_get_slot(js->current_func, SLOT_DATA); ant_value_t result = (nargs > 0) ? args[0] : js_mkundef(); ant_value_t promise = js_get(js, state, "promise"); ant_value_t reader = js_get(js, state, "reader"); ant_value_t chunks = js_get(js, state, "chunks"); int mode = (int)js_getnum(js_get(js, state, "mode"));
ant_value_t done_val = js_get(js, result, "done"); ant_value_t value = js_get(js, result, "value");
if (vtype(done_val) == T_BOOL && done_val == js_true) { size_t size = 0; uint8_t *data = concat_chunks(js, chunks, &size); ant_value_t type_v = js_get(js, state, "type"); const char *body_type = (vtype(type_v) == T_STR) ? js_getstr(js, type_v, NULL) : NULL; resolve_body_promise(js, promise, data, size, body_type, mode, true); free(data); return js_mkundef(); }
if (vtype(value) != T_UNDEF && vtype(value) != T_NULL) js_arr_push(js, chunks, value);
stream_schedule_next_read(js, state, js_mkundef(), reader); return js_mkundef();}
static ant_value_t consume_body_from_stream( ant_t *js, ant_value_t stream, ant_value_t promise, int mode, const char *body_type) { ant_value_t reader_args[1] = { stream }; ant_value_t saved = js->new_target; js->new_target = g_reader_proto; ant_value_t reader = js_rs_reader_ctor(js, reader_args, 1); js->new_target = saved; if (is_err(reader)) { js_reject_promise(js, promise, reader); return promise; }
ant_value_t state = js_mkobj(js); js_set(js, state, "promise", promise); js_set(js, state, "reader", reader); js_set(js, state, "chunks", js_mkarr(js)); js_set(js, state, "mode", js_mknum(mode)); js_set(js, state, "type", body_type ? js_mkstr(js, body_type, strlen(body_type)) : js_mkundef());
stream_schedule_next_read(js, state, js_mkundef(), reader); return promise;}
static ant_value_t consume_body(ant_t *js, int mode) { ant_value_t this = js_getthis(js); request_data_t *d = get_data(this); ant_value_t promise = js_mkpromise(js);
if (!d) { js_reject_promise(js, promise, request_rejection_reason(js, js_mkerr_typed(js, JS_ERR_TYPE, "Invalid Request object"))); return promise; } if (!d->has_body) { resolve_body_promise(js, promise, NULL, 0, request_effective_body_type(js, this, d), mode, false); return promise; } if (d->body_used) { js_reject_promise(js, promise, request_rejection_reason(js, js_mkerr_typed(js, JS_ERR_TYPE, "body stream is disturbed or locked"))); return promise; } d->body_used = true; ant_value_t stream = js_get_slot(this, SLOT_REQUEST_BODY_STREAM); if (rs_is_stream(stream) && d->body_is_stream) return consume_body_from_stream(js, stream, promise, mode, request_effective_body_type(js, this, d)); resolve_body_promise(js, promise, d->body_data, d->body_size, request_effective_body_type(js, this, d), mode, true); return promise;}
static ant_value_t js_req_text(ant_t *js, ant_value_t *args, int nargs) { return consume_body(js, BODY_TEXT);}
static ant_value_t js_req_json(ant_t *js, ant_value_t *args, int nargs) { return consume_body(js, BODY_JSON);}
static ant_value_t js_req_array_buffer(ant_t *js, ant_value_t *args, int nargs) { return consume_body(js, BODY_ARRAYBUFFER);}
static ant_value_t js_req_blob(ant_t *js, ant_value_t *args, int nargs) { return consume_body(js, BODY_BLOB);}
static ant_value_t js_req_bytes(ant_t *js, ant_value_t *args, int nargs) { return consume_body(js, BODY_BYTES);}
static ant_value_t js_req_form_data(ant_t *js, ant_value_t *args, int nargs) { return consume_body(js, BODY_FORMDATA);}
static ant_value_t request_set_extracted_body( ant_t *js, ant_value_t req_obj, ant_value_t headers, request_data_t *req, uint8_t *body_data, size_t body_size, char *body_type, ant_value_t body_stream, bool duplex_provided) { free(req->body_data); free(req->body_type);
req->body_data = body_data; req->body_size = body_size; req->body_type = body_type; req->body_is_stream = rs_is_stream(body_stream); req->has_body = true;
if (!req->body_is_stream) { if (body_type && body_type[0]) headers_append_if_missing(headers, "content-type", body_type); return js_mkundef(); }
if (req->keepalive) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': keepalive cannot be used with a ReadableStream body"); } if (!duplex_provided) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': duplex must be provided for a ReadableStream body"); }
js_set_slot_wb(js, req_obj, SLOT_REQUEST_BODY_STREAM, body_stream); if (body_type && body_type[0]) headers_append_if_missing(headers, "content-type", body_type); return js_mkundef();}
static void request_clear_body(ant_t *js, ant_value_t req_obj, request_data_t *req) { free(req->body_data); free(req->body_type); req->body_data = NULL; req->body_size = 0; req->body_type = NULL; req->body_is_stream = false; req->has_body = false; js_set_slot_wb(js, req_obj, SLOT_REQUEST_BODY_STREAM, js_mkundef());}
static ant_value_t request_copy_source_body(ant_t *js, ant_value_t req_obj, ant_value_t input, request_data_t *req, request_data_t *src) { ant_value_t src_stream = js_get_slot(input, SLOT_REQUEST_BODY_STREAM);
if (src->body_used) { return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot construct Request with unusable body"); }
if (rs_is_stream(src_stream) && rs_stream_unusable(src_stream)) { return js_mkerr_typed(js, JS_ERR_TYPE, "body stream is disturbed or locked"); }
if (!src->body_is_stream) { req->body_data = malloc(src->body_size); if (src->body_size > 0 && !req->body_data) return js_mkerr(js, "out of memory"); if (src->body_size > 0) memcpy(req->body_data, src->body_data, src->body_size); req->body_size = src->body_size; req->body_type = src->body_type ? strdup(src->body_type) : NULL; req->body_is_stream = false; req->has_body = true; return js_mkundef(); }
if (!rs_is_stream(src_stream)) return js_mkundef(); ant_value_t branches = readable_stream_tee(js, src_stream); if (is_err(branches)) return branches; if (vtype(branches) != T_ARR) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': tee() did not return branches"); }
js_set_slot_wb(js, req_obj, SLOT_REQUEST_BODY_STREAM, js_arr_get(js, branches, 1)); req->body_is_stream = true; req->has_body = true; return js_mkundef();}
#define REQ_GETTER_START(name) \ static ant_value_t js_req_get_##name(ant_t *js, ant_value_t *args, int nargs) { \ ant_value_t this = js_getthis(js); \ request_data_t *d = get_data(this); \ if (!d) return js_mkundef();
#define REQ_GETTER_END }
REQ_GETTER_START(method) return js_mkstr(js, d->method, strlen(d->method));REQ_GETTER_END
REQ_GETTER_START(url) char *href = build_href(&d->url); if (!href) return js_mkstr(js, "", 0); ant_value_t ret = js_mkstr(js, href, strlen(href)); free(href); return ret;REQ_GETTER_END
REQ_GETTER_START(headers) return js_get_slot(this, SLOT_REQUEST_HEADERS);REQ_GETTER_END
REQ_GETTER_START(destination) (void)d; return js_mkstr(js, "", 0);REQ_GETTER_END
REQ_GETTER_START(referrer) if (!d->referrer || strcmp(d->referrer, "no-referrer") == 0) return js_mkstr(js, "", 0); if (strcmp(d->referrer, "client") == 0) return js_mkstr(js, "about:client", 12); return js_mkstr(js, d->referrer, strlen(d->referrer));REQ_GETTER_END
REQ_GETTER_START(referrer_policy) const char *p = d->referrer_policy ? d->referrer_policy : ""; return js_mkstr(js, p, strlen(p));REQ_GETTER_END
REQ_GETTER_START(mode) return js_mkstr(js, d->mode, strlen(d->mode));REQ_GETTER_END
REQ_GETTER_START(credentials) return js_mkstr(js, d->credentials, strlen(d->credentials));REQ_GETTER_END
REQ_GETTER_START(cache) return js_mkstr(js, d->cache, strlen(d->cache));REQ_GETTER_END
REQ_GETTER_START(redirect) return js_mkstr(js, d->redirect, strlen(d->redirect));REQ_GETTER_END
REQ_GETTER_START(integrity) const char *ig = d->integrity ? d->integrity : ""; return js_mkstr(js, ig, strlen(ig));REQ_GETTER_END
REQ_GETTER_START(keepalive) return js_bool(d->keepalive);REQ_GETTER_END
REQ_GETTER_START(is_reload_navigation) return js_bool(d->reload_navigation);REQ_GETTER_END
REQ_GETTER_START(is_history_navigation) return js_bool(d->history_navigation);REQ_GETTER_END
REQ_GETTER_START(signal) return request_get_signal(js, this);REQ_GETTER_END
REQ_GETTER_START(duplex) return js_mkstr(js, "half", 4);REQ_GETTER_END
static ant_value_t req_body_pull(ant_t *js, ant_value_t *args, int nargs) { ant_value_t req_obj = js_get_slot(js->current_func, SLOT_DATA); request_data_t *d = get_data(req_obj); ant_value_t ctrl = (nargs > 0) ? args[0] : js_mkundef();
if (d && d->body_data && d->body_size > 0) { ArrayBufferData *ab = create_array_buffer_data(d->body_size); if (ab) { memcpy(ab->data, d->body_data, d->body_size); rs_controller_enqueue(js, ctrl, create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, d->body_size, "Uint8Array")); }} rs_controller_close(js, ctrl); return js_mkundef();}
REQ_GETTER_START(body) if (!d->has_body) return js_mknull(); ant_value_t stored_stream = js_get_slot(this, SLOT_REQUEST_BODY_STREAM); if (rs_is_stream(stored_stream)) return stored_stream; if (d->body_used) return js_mknull(); ant_value_t pull = js_heavy_mkfun(js, req_body_pull, this); ant_value_t stream = rs_create_stream(js, pull, js_mkundef(), 1.0); if (!is_err(stream)) js_set_slot_wb(js, this, SLOT_REQUEST_BODY_STREAM, stream); return stream;REQ_GETTER_END
REQ_GETTER_START(body_used) return js_bool(d->body_used);REQ_GETTER_END
#undef REQ_GETTER_START#undef REQ_GETTER_END
static ant_value_t request_inspect_finish(ant_t *js, ant_value_t this_obj, ant_value_t body_obj) { ant_value_t tag_val = js_get_sym(js, this_obj, get_toStringTag_sym()); const char *tag = vtype(tag_val) == T_STR ? js_getstr(js, tag_val, NULL) : "Request";
js_inspect_builder_t builder; if (!js_inspect_builder_init_dynamic(&builder, js, 128)) { return js_mkerr(js, "out of memory"); }
bool ok = js_inspect_header_for(&builder, body_obj, "%s", tag); if (ok) ok = js_inspect_object_body(&builder, body_obj); if (ok) ok = js_inspect_close(&builder);
if (!ok) { js_inspect_builder_dispose(&builder); return js_mkerr(js, "out of memory"); }
return js_inspect_builder_result(&builder);}
// TODO: make drystatic bool request_inspect_set( ant_t *js, ant_value_t obj, const char *key, ant_value_t value, ant_value_t *err_out) { if (is_err(value)) { *err_out = value; return false; }
js_set(js, obj, key, value); return true;}
static ant_value_t request_inspect(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this_obj = js_getthis(js); ant_value_t out = js_mkobj(js); ant_value_t err = 0;
if (!request_inspect_set(js, out, "method", js_req_get_method(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "url", js_req_get_url(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "headers", js_req_get_headers(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "destination", js_req_get_destination(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "referrer", js_req_get_referrer(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "referrerPolicy", js_req_get_referrer_policy(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "mode", js_req_get_mode(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "credentials", js_req_get_credentials(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "cache", js_req_get_cache(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "redirect", js_req_get_redirect(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "integrity", js_req_get_integrity(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "keepalive", js_req_get_keepalive(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "isReloadNavigation", js_req_get_is_reload_navigation(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "isHistoryNavigation", js_req_get_is_history_navigation(js, NULL, 0), &err)) return err; if (!request_inspect_set(js, out, "signal", js_req_get_signal(js, NULL, 0), &err)) return err;
return request_inspect_finish(js, this_obj, out);}
static ant_value_t js_request_clone(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this = js_getthis(js); request_data_t *d = get_data(this); if (!d) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid Request object"); if (d->body_used) return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot clone a Request whose body is unusable");
request_data_t *nd = data_dup(d); if (!nd) return js_mkerr(js, "out of memory");
ant_value_t src_headers = js_get_slot(this, SLOT_REQUEST_HEADERS); ant_value_t src_signal = request_get_signal(js, this);
ant_value_t new_headers = headers_create_empty(js); if (is_err(new_headers)) { data_free(nd); return new_headers; } headers_copy_from(js, new_headers, src_headers); headers_set_guard(new_headers, strcmp(nd->mode, "no-cors") == 0 ? HEADERS_GUARD_REQUEST_NO_CORS : HEADERS_GUARD_REQUEST ); headers_apply_guard(new_headers);
ant_value_t new_signal = abort_signal_create_dependent(js, src_signal); if (is_err(new_signal)) { data_free(nd); return new_signal; }
ant_value_t obj = js_mkobj(js); js_set_proto_init(obj, g_request_proto); js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST)); js_set_slot(obj, SLOT_DATA, ANT_PTR(nd)); js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, new_headers); js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef()); js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, new_signal);
ant_value_t src_stream = js_get_slot(this, SLOT_REQUEST_BODY_STREAM); if (rs_is_stream(src_stream)) { ant_value_t branches = readable_stream_tee(js, src_stream); if (!is_err(branches) && vtype(branches) == T_ARR) { ant_value_t b1 = js_arr_get(js, branches, 0); ant_value_t b2 = js_arr_get(js, branches, 1); js_set_slot_wb(js, this, SLOT_REQUEST_BODY_STREAM, b1); js_set_slot_wb(js, obj, SLOT_REQUEST_BODY_STREAM, b2); }}
return obj;}
static const char *init_str(ant_t *js, ant_value_t init, const char *key, size_t klen, ant_value_t *err_out) { ant_value_t v = js_get(js, init, key); if (vtype(v) == T_UNDEF) return NULL; if (vtype(v) != T_STR) { v = js_tostring_val(js, v); if (is_err(v)) { *err_out = v; return NULL; } } return js_getstr(js, v, NULL);}
static ant_value_t request_new_from_input( ant_t *js, ant_value_t input, request_data_t **out_req, request_data_t **out_src, ant_value_t *out_input_signal) { request_data_t *req = NULL; request_data_t *src = NULL;
*out_req = NULL; *out_src = NULL; *out_input_signal = js_mkundef();
if ( vtype(input) == T_OBJ && js_check_brand(input, BRAND_REQUEST) ) src = get_data(input);
if (!src) { size_t ulen = 0; const char *url_str = NULL; url_state_t parsed = {0};
if (vtype(input) != T_STR) { input = js_tostring_val(js, input); if (is_err(input)) return input; }
url_str = js_getstr(js, input, &ulen); if (parse_url_to_state(url_str, NULL, &parsed) != 0) { url_state_clear(&parsed); return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Invalid URL"); } if ((parsed.username && parsed.username[0]) || (parsed.password && parsed.password[0])) { url_state_clear(&parsed); return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': URL includes credentials"); }
req = data_new(); if (!req) { url_state_clear(&parsed); return js_mkerr(js, "out of memory"); } req->url = parsed; } else { req = data_dup(src); if (!req) return js_mkerr(js, "out of memory"); req->body_used = false; *out_input_signal = request_get_signal(js, input); }
*out_req = req; *out_src = src; return js_mkundef();}
static ant_value_t request_apply_init_options( ant_t *js, ant_value_t init, request_data_t *req, ant_value_t *input_signal) { ant_value_t err = js_mkundef(); ant_value_t win = js_get(js, init, "window"); const char *ref = NULL; const char *rp = NULL; const char *mode_val = NULL; const char *cred = NULL; const char *cache_val = NULL; const char *redir = NULL; const char *integ = NULL; const char *method_val = NULL;
if (vtype(win) != T_UNDEF && vtype(win) != T_NULL) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': 'window' must be null"); }
if (strcmp(req->mode, "navigate") == 0) { free(req->mode); req->mode = strdup("same-origin"); } req->reload_navigation = false; req->history_navigation = false; free(req->referrer); req->referrer = strdup("client"); free(req->referrer_policy); req->referrer_policy = strdup("");
ref = init_str(js, init, "referrer", 8, &err); if (is_err(err)) return err; if (ref) { if (ref[0] == '\0') { free(req->referrer); req->referrer = strdup("no-referrer"); } else { url_state_t rs = {0}; if (parse_url_to_state(ref, NULL, &rs) != 0) { url_state_clear(&rs); return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Invalid referrer URL"); } free(req->referrer); req->referrer = build_href(&rs); url_state_clear(&rs); if (!req->referrer) req->referrer = strdup("client"); }}
rp = init_str(js, init, "referrerPolicy", 14, &err); if (is_err(err)) return err; if (rp) { free(req->referrer_policy); req->referrer_policy = strdup(rp); }
mode_val = init_str(js, init, "mode", 4, &err); if (is_err(err)) return err; if (mode_val) { if (strcmp(mode_val, "navigate") == 0) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': mode 'navigate' is not allowed"); } free(req->mode); req->mode = strdup(mode_val); }
cred = init_str(js, init, "credentials", 11, &err); if (is_err(err)) return err; if (cred) { free(req->credentials); req->credentials = strdup(cred); }
cache_val = init_str(js, init, "cache", 5, &err); if (is_err(err)) return err; if (cache_val) { free(req->cache); req->cache = strdup(cache_val); if ( strcmp(req->cache, "only-if-cached") == 0 && strcmp(req->mode, "same-origin") != 0 ) return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': cache mode 'only-if-cached' requires mode 'same-origin'"); }
redir = init_str(js, init, "redirect", 8, &err); if (is_err(err)) return err; if (redir) { free(req->redirect); req->redirect = strdup(redir); }
integ = init_str(js, init, "integrity", 9, &err); if (is_err(err)) return err; if (integ) { free(req->integrity); req->integrity = strdup(integ); }
ant_value_t ka = js_get(js, init, "keepalive"); if (vtype(ka) != T_UNDEF) req->keepalive = js_truthy(js, ka);
method_val = init_str(js, init, "method", 6, &err); if (is_err(err)) return err; if (method_val) { if (!is_valid_method(method_val)) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Invalid method"); } if (is_forbidden_method(method_val)) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Forbidden method"); } free(req->method); req->method = strdup(method_val); normalize_method(req->method); }
ant_value_t sig_val = js_get(js, init, "signal"); if (vtype(sig_val) == T_UNDEF) return js_mkundef(); if (vtype(sig_val) == T_NULL) { *input_signal = js_mkundef(); return js_mkundef(); } if (abort_signal_is_signal(sig_val)) { *input_signal = sig_val; return js_mkundef(); }
return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': signal must be an AbortSignal");}
static ant_value_t request_create_ctor_headers(ant_t *js, ant_value_t input) { ant_value_t headers = headers_create_empty(js); if (is_err(headers)) return headers; if (vtype(input) != T_OBJ) return headers;
ant_value_t src_hdrs = js_get_slot(input, SLOT_REQUEST_HEADERS); headers_copy_from(js, headers, src_hdrs); return headers;}
static ant_value_t request_apply_init_headers(ant_t *js, ant_value_t init, ant_value_t headers) { ant_value_t init_headers = js_get(js, init, "headers"); if (vtype(init_headers) == T_UNDEF) return headers; return headers_create_from_init(js, init_headers);}
static ant_value_t request_parse_duplex(ant_t *js, ant_value_t init, bool *out_duplex_provided) { ant_value_t duplex_val = js_get(js, init, "duplex"); ant_value_t duplex_str_v = duplex_val; const char *duplex_str = NULL;
*out_duplex_provided = vtype(duplex_val) != T_UNDEF; if (!*out_duplex_provided) return js_mkundef();
if (vtype(duplex_str_v) != T_STR) { duplex_str_v = js_tostring_val(js, duplex_str_v); if (is_err(duplex_str_v)) return duplex_str_v; }
duplex_str = js_getstr(js, duplex_str_v, NULL); if (duplex_str && strcmp(duplex_str, "half") == 0) return js_mkundef();
return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': duplex must be 'half'");}
static ant_value_t request_apply_ctor_body( ant_t *js, ant_value_t req_obj, ant_value_t input, ant_value_t init, bool init_provided, bool duplex_provided, request_data_t *req, request_data_t *src, ant_value_t headers) { if (init_provided) { ant_value_t body_val = js_get(js, init, "body"); bool init_body_present = vtype(body_val) != T_UNDEF; bool input_body_present = src && src->has_body; bool effective_body_present = (init_body_present && vtype(body_val) != T_NULL) || (input_body_present && (!init_body_present || vtype(body_val) == T_NULL));
if ((strcmp(req->method, "GET") == 0 || strcmp(req->method, "HEAD") == 0) && effective_body_present) { return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': Request with GET/HEAD method cannot have body"); }
if (vtype(body_val) == T_UNDEF) return js_mkundef(); if (vtype(body_val) == T_NULL) { request_clear_body(js, req_obj, req); return js_mkundef(); }
request_data_t *init_req = get_data(init); ant_value_t body_err = js_mkundef(); ant_value_t body_stream = js_mkundef(); uint8_t *bd = NULL; size_t bs = 0; char *bt = NULL; if (init_req && !init_req->body_used && !init_req->body_is_stream && init_req->has_body) { bd = malloc(init_req->body_size); if (init_req->body_size > 0 && !bd) return js_mkerr(js, "out of memory"); if (init_req->body_size > 0) memcpy(bd, init_req->body_data, init_req->body_size); bs = init_req->body_size; bt = init_req->body_type ? strdup(init_req->body_type) : NULL; } else if (!extract_body(js, body_val, &bd, &bs, &bt, &body_stream, &body_err)) return is_err(body_err) ? body_err : js_mkerr(js, "Failed to extract body"); return request_set_extracted_body( js, req_obj, headers, req, bd, bs, bt, body_stream, duplex_provided ); }
if (!src) return js_mkundef(); return request_copy_source_body(js, req_obj, input, req, src);}
static ant_value_t js_request_ctor(ant_t *js, ant_value_t *args, int nargs) { ant_value_t init = (nargs >= 2 && vtype(args[1]) != T_UNDEF) ? args[1] : js_mkundef();
if (vtype(js->new_target) == T_UNDEF) return js_mkerr_typed(js, JS_ERR_TYPE, "Request constructor requires 'new'"); if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "Request constructor requires at least 1 argument");
ant_value_t input = args[0]; ant_value_t obj = 0; ant_value_t proto = 0; bool init_provided = false; request_data_t *req = NULL; request_data_t *src = NULL; ant_value_t input_signal = js_mkundef(); ant_value_t step = js_mkundef(); ant_value_t signal = 0; ant_value_t headers = 0; bool duplex_provided = false; init_provided = (vtype(init) == T_OBJ || vtype(init) == T_ARR); step = request_new_from_input(js, input, &req, &src, &input_signal); if (is_err(step)) return step;
if (init_provided) { step = request_apply_init_options(js, init, req, &input_signal); if (is_err(step)) { data_free(req); return step; } }
if ( strcmp(req->mode, "no-cors") == 0 && !is_cors_safelisted_method(req->method) ) { data_free(req); return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': method must be one of GET, HEAD, POST for no-cors mode"); }
obj = js_mkobj(js); proto = js_instance_proto_from_new_target(js, g_request_proto); if (is_object_type(proto)) js_set_proto_init(obj, proto); else js_set_proto_init(obj, g_request_proto); js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST)); js_set_slot(obj, SLOT_DATA, ANT_PTR(req)); js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef());
signal = abort_signal_create_dependent(js, input_signal); if (is_err(signal)) { data_free(req); return signal; } js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, signal);
headers = request_create_ctor_headers(js, input); if (is_err(headers)) { data_free(req); return headers; } if (init_provided) { headers = request_apply_init_headers(js, init, headers); if (is_err(headers)) { data_free(req); return headers; } }
headers_set_guard(headers, strcmp(req->mode, "no-cors") == 0 ? HEADERS_GUARD_REQUEST_NO_CORS : HEADERS_GUARD_REQUEST ); headers_apply_guard(headers); js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, headers);
if (init_provided) { step = request_parse_duplex(js, init, &duplex_provided); if (is_err(step)) { data_free(req); return step; } }
step = request_apply_ctor_body( js, obj, input, init, init_provided, duplex_provided, req, src, headers ); if (is_err(step)) { data_free(req); return step; }
if (src && src->has_body && !src->body_used) src->body_used = true;
return obj;}
ant_value_t request_create_from_input_init(ant_t *js, ant_value_t input, ant_value_t init) { bool init_provided = (vtype(init) == T_OBJ || vtype(init) == T_ARR); request_data_t *req = NULL; request_data_t *src = NULL; ant_value_t input_signal = js_mkundef(); ant_value_t step = js_mkundef(); ant_value_t obj = 0; ant_value_t signal = 0; ant_value_t headers = 0; bool duplex_provided = false; step = request_new_from_input(js, input, &req, &src, &input_signal); if (is_err(step)) return step;
if (init_provided) { step = request_apply_init_options(js, init, req, &input_signal); if (is_err(step)) { data_free(req); return step; } }
if ( strcmp(req->mode, "no-cors") == 0 && !is_cors_safelisted_method(req->method) ) { data_free(req); return js_mkerr_typed(js, JS_ERR_TYPE, "Failed to construct 'Request': method must be one of GET, HEAD, POST for no-cors mode"); }
obj = js_mkobj(js); js_set_proto_init(obj, g_request_proto); js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_REQUEST)); js_set_slot(obj, SLOT_DATA, ANT_PTR(req)); js_set_slot(obj, SLOT_REQUEST_ABORT_REASON, js_mkundef());
signal = abort_signal_create_dependent(js, input_signal); if (is_err(signal)) { data_free(req); return signal; } js_set_slot_wb(js, obj, SLOT_REQUEST_SIGNAL, signal);
headers = request_create_ctor_headers(js, input); if (is_err(headers)) { data_free(req); return headers; } if (init_provided) { headers = request_apply_init_headers(js, init, headers); if (is_err(headers)) { data_free(req); return headers; } }
headers_set_guard(headers, strcmp(req->mode, "no-cors") == 0 ? HEADERS_GUARD_REQUEST_NO_CORS : HEADERS_GUARD_REQUEST ); headers_apply_guard(headers); js_set_slot_wb(js, obj, SLOT_REQUEST_HEADERS, headers);
if (init_provided) { step = request_parse_duplex(js, init, &duplex_provided); if (is_err(step)) { data_free(req); return step; } }
step = request_apply_ctor_body(js, obj, input, init, init_provided, duplex_provided, req, src, headers); if (is_err(step)) { data_free(req); return step; }
if (src && src->has_body && !src->body_used) src->body_used = true;
return obj;}
ant_value_t request_create(ant_t *js, const char *method, const char *url, ant_value_t headers_obj, const uint8_t *body, size_t body_len, const char *body_type) { request_data_t *req = data_new(); if (!req) return js_mkerr(js, "out of memory");
free(req->method); req->method = strdup(method ? method : "GET"); free(req->mode); req->mode = strdup("same-origin");
url_state_t parsed = {0}; if (url && parse_url_to_state(url, NULL, &parsed) == 0) req->url = parsed; else url_state_clear(&parsed);
if (body) req->has_body = true; if (body && body_len > 0) { req->body_data = malloc(body_len); if (!req->body_data) { data_free(req); return js_mkerr(js, "out of memory"); } memcpy(req->body_data, body, body_len); req->body_size = body_len; req->body_type = body_type ? strdup(body_type) : NULL; } req->body_is_stream = false; return request_create_object(js, req, headers_obj, true);}
ant_value_t request_create_server( ant_t *js, const char *method, const char *target, bool absolute_target, const char *host, const char *server_hostname, int server_port, ant_value_t headers_obj, const uint8_t *body, size_t body_len, const char *body_type) { request_data_t *req = data_new_server(method); if (!req) return js_mkerr(js, "out of memory");
if (target && request_parse_server_url(target, absolute_target, host, server_hostname, server_port, &req->url) != 0) url_state_clear(&req->url);
if (body) req->has_body = true;
if (body && body_len > 0) { req->body_data = malloc(body_len); if (!req->body_data) { data_free(req); return js_mkerr(js, "out of memory"); } memcpy(req->body_data, body, body_len); req->body_size = body_len; req->body_type = body_type ? strdup(body_type) : NULL; } req->body_is_stream = false;
return request_create_object(js, req, headers_obj, false);}
void init_request_module(void) { ant_t *js = rt->js; ant_value_t g = js_glob(js); g_request_proto = js_mkobj(js);
js_set(js, g_request_proto, "text", js_mkfun(js_req_text)); js_set(js, g_request_proto, "json", js_mkfun(js_req_json)); js_set(js, g_request_proto, "arrayBuffer", js_mkfun(js_req_array_buffer)); js_set(js, g_request_proto, "blob", js_mkfun(js_req_blob)); js_set(js, g_request_proto, "formData", js_mkfun(js_req_form_data)); js_set(js, g_request_proto, "bytes", js_mkfun(js_req_bytes)); js_set(js, g_request_proto, "clone", js_mkfun(js_request_clone));
#define GETTER(prop, fn) \ js_set_getter_desc(js, g_request_proto, prop, sizeof(prop)-1, js_mkfun(js_req_get_##fn), JS_DESC_C) GETTER("method", method); GETTER("url", url); GETTER("headers", headers); GETTER("destination", destination); GETTER("referrer", referrer); GETTER("referrerPolicy", referrer_policy); GETTER("mode", mode); GETTER("credentials", credentials); GETTER("cache", cache); GETTER("redirect", redirect); GETTER("integrity", integrity); GETTER("keepalive", keepalive); GETTER("isReloadNavigation",is_reload_navigation); GETTER("isHistoryNavigation",is_history_navigation); GETTER("signal", signal); GETTER("duplex", duplex); GETTER("body", body); GETTER("bodyUsed", body_used);#undef GETTER
js_set_sym(js, g_request_proto, get_inspect_sym(), js_mkfun(request_inspect)); js_set_sym(js, g_request_proto, get_toStringTag_sym(), js_mkstr(js, "Request", 7)); ant_value_t ctor = js_make_ctor(js, js_request_ctor, g_request_proto, "Request", 7); js_set(js, g, "Request", ctor); js_set_descriptor(js, g, "Request", 7, JS_DESC_W | JS_DESC_C);}