MIRROR: javascript for ๐Ÿœ's, a tiny runtime with big ambitions
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

TransformStream

+137 -94
+5 -3
examples/spec/streams-transform.js
··· 2 2 3 3 console.log('TransformStream / TransformStreamDefaultController Tests\n'); 4 4 5 + const READABLE_NO_BACKPRESSURE = { highWaterMark: 1 }; 6 + 5 7 test('TS typeof', typeof TransformStream, 'function'); 6 8 test('TS toStringTag', Object.prototype.toString.call(new TransformStream()), '[object TransformStream]'); 7 9 ··· 101 103 const err = new Error('transform boom'); 102 104 const ts = new TransformStream({ 103 105 transform() { throw err; } 104 - }); 106 + }, undefined, READABLE_NO_BACKPRESSURE); 105 107 const writer = ts.writable.getWriter(); 106 108 const reader = ts.readable.getReader(); 107 109 try { ··· 123 125 const ts = new TransformStream({ 124 126 transform() {}, 125 127 flush() { throw err; } 126 - }); 128 + }, undefined, READABLE_NO_BACKPRESSURE); 127 129 const writer = ts.writable.getWriter(); 128 130 await writer.write('a'); 129 131 try { ··· 272 274 273 275 async function testReadableHWM() { 274 276 let ctrl; 275 - const ts = new TransformStream({ 277 + new TransformStream({ 276 278 start(c) { ctrl = c; } 277 279 }, undefined, { highWaterMark: 9 }); 278 280 test('readable custom HWM desiredSize', ctrl.desiredSize, 9);
+15 -7
src/streams/pipes.c
··· 429 429 } 430 430 431 431 static ant_value_t js_rs_pipe_through(ant_t *js, ant_value_t *args, int nargs) { 432 - if (!is_object_type(js->this_val)) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid ReadableStream"); 433 - rs_stream_t *stream = rs_get_stream(js->this_val); 432 + ant_value_t source = js->this_val; 433 + if (!is_object_type(source)) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid ReadableStream"); 434 + rs_stream_t *stream = rs_get_stream(source); 434 435 435 436 if (!stream) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid ReadableStream"); 436 - if (is_object_type(rs_stream_reader(js->this_val))) 437 + if (is_object_type(rs_stream_reader(source))) 437 438 return js_mkerr_typed(js, JS_ERR_TYPE, "ReadableStream is already locked"); 438 439 if (nargs < 1 || !is_object_type(args[0])) 439 440 return js_mkerr_typed(js, JS_ERR_TYPE, "pipeThrough requires a transform object"); ··· 441 442 ant_value_t transform = args[0]; 442 443 ant_value_t writable = js_get(js, transform, "writable"); 443 444 ant_value_t readable = js_get(js, transform, "readable"); 445 + 444 446 if (!is_object_type(writable) || !ws_get_stream(writable)) 445 447 return js_mkerr_typed(js, JS_ERR_TYPE, "pipeThrough transform.writable must be a WritableStream"); 446 448 if (!is_object_type(readable) || !rs_get_stream(readable)) ··· 450 452 451 453 bool prevent_close, prevent_abort, prevent_cancel; 452 454 ant_value_t signal; 453 - pipes_parse_options(js, nargs > 1 ? args[1] : js_mkundef(), 454 - &prevent_close, &prevent_abort, &prevent_cancel, &signal); 455 + 456 + pipes_parse_options( 457 + js, nargs > 1 ? args[1] : js_mkundef(), 458 + &prevent_close, &prevent_abort, &prevent_cancel, &signal 459 + ); 455 460 456 - ant_value_t pipe_promise = readable_stream_pipe_to(js, js->this_val, writable, 457 - prevent_close, prevent_abort, prevent_cancel, signal); 461 + ant_value_t pipe_promise = readable_stream_pipe_to( 462 + js, source, writable, 463 + prevent_close, prevent_abort, prevent_cancel, signal 464 + ); 465 + 458 466 promise_mark_handled(pipe_promise); 459 467 return readable; 460 468 }
+30 -2
src/streams/readable.c
··· 510 510 return; 511 511 } 512 512 513 + double chunk_size = 1; 514 + ant_value_t size_fn = rs_ctrl_size(ctrl_obj); 515 + if (is_callable(size_fn)) { 516 + ant_value_t size_args[1] = { chunk }; 517 + ant_value_t size_result = sv_vm_call(js->vm, js, size_fn, js_mkundef(), size_args, 1, NULL, false); 518 + if (is_err(size_result)) { 519 + ant_value_t thrown = js->thrown_value; 520 + ant_value_t err = is_object_type(thrown) ? thrown : size_result; 521 + js->thrown_exists = false; 522 + js->thrown_value = js_mkundef(); 523 + js->thrown_stack = js_mkundef(); 524 + readable_stream_error(js, stream_obj, err); 525 + return; 526 + } 527 + if (vtype(size_result) == T_NUM) chunk_size = js_getnum(size_result); 528 + else chunk_size = js_to_number(js, size_result); 529 + } 530 + 531 + if (chunk_size < 0 || chunk_size != chunk_size || chunk_size == (double)INFINITY) { 532 + ant_value_t err = js_make_error_silent(js, JS_ERR_RANGE, 533 + "The return value of a queuing strategy's size function must be a finite, non-NaN, non-negative number"); 534 + readable_stream_error(js, stream_obj, err); 535 + return; 536 + } 537 + 513 538 rs_ctrl_queue_push(js, ctrl_obj, chunk); 514 539 if (ctrl->queue_sizes_len >= ctrl->queue_sizes_cap) { 515 540 uint32_t new_cap = ctrl->queue_sizes_cap ? ctrl->queue_sizes_cap * 2 : 4; ··· 518 543 } 519 544 520 545 if (ctrl->queue_sizes_len < ctrl->queue_sizes_cap) 521 - ctrl->queue_sizes[ctrl->queue_sizes_len++] = 1; 522 - ctrl->queue_total_size += 1; 546 + ctrl->queue_sizes[ctrl->queue_sizes_len++] = chunk_size; 547 + ctrl->queue_total_size += chunk_size; 523 548 rs_default_controller_call_pull_if_needed(js, ctrl_obj); 524 549 } 525 550 ··· 604 629 return js_mkerr_typed(js, JS_ERR_TYPE, "ReadableStream is already locked to a reader"); 605 630 606 631 ant_value_t closed = js_mkpromise(js); 632 + promise_mark_handled(closed); 633 + 607 634 ant_value_t obj = js_mkobj(js); 608 635 ant_value_t proto = js_instance_proto_from_new_target(js, g_reader_proto); 636 + 609 637 if (is_object_type(proto)) js_set_proto_init(obj, proto); 610 638 js_set_slot(obj, SLOT_ENTRIES, stream_obj); 611 639 js_set_slot(obj, SLOT_RS_CLOSED, closed);
+48 -69
src/streams/transform.c
··· 8 8 #include "descriptors.h" 9 9 10 10 #include "silver/engine.h" 11 + #include "modules/assert.h" 11 12 #include "modules/symbol.h" 12 13 #include "streams/transform.h" 13 14 #include "streams/readable.h" ··· 100 101 return js_get_slot(ctrl_obj, SLOT_BUFFER); 101 102 } 102 103 104 + static inline ant_value_t ts_ctrl_transformer(ant_value_t ctrl_obj) { 105 + return js_get_slot(ctrl_obj, SLOT_SETTLED); 106 + } 107 + 103 108 static inline ant_value_t ts_ctrl_stream(ant_value_t ctrl_obj) { 104 109 return js_get_slot(ctrl_obj, SLOT_DATA); 105 110 } ··· 114 119 js_set_slot(ctrl_obj, SLOT_BUFFER, js_mkundef()); 115 120 } 116 121 122 + static ant_value_t ts_take_thrown_or(ant_t *js, ant_value_t fallback) { 123 + ant_value_t thrown = js->thrown_exists ? js->thrown_value : js_mkundef(); 124 + ant_value_t err = is_object_type(thrown) ? thrown : fallback; 125 + js->thrown_exists = false; 126 + js->thrown_value = js_mkundef(); 127 + js->thrown_stack = js_mkundef(); 128 + return err; 129 + } 130 + 117 131 static bool ts_is_thenable(ant_t *js, ant_value_t val) { 118 132 if (vtype(val) == T_PROMISE) return true; 119 133 if (!is_object_type(val)) return false; ··· 123 137 124 138 static void ts_chain_thenable(ant_t *js, ant_value_t val, ant_value_t res_fn, ant_value_t rej_fn) { 125 139 if (vtype(val) == T_PROMISE) { 126 - ant_value_t then_fn = js_get(js, val, "then"); 127 - if (is_callable(then_fn)) { 128 - ant_value_t then_args[2] = { res_fn, rej_fn }; 129 - sv_vm_call(js->vm, js, then_fn, val, then_args, 2, NULL, false); 130 - } 131 - } else { 132 - ant_value_t resolved = js_mkpromise(js); 133 - js_resolve_promise(js, resolved, val); 134 - ant_value_t then_fn = js_get(js, resolved, "then"); 135 - if (is_callable(then_fn)) { 136 - ant_value_t then_args[2] = { res_fn, rej_fn }; 137 - sv_vm_call(js->vm, js, then_fn, resolved, then_args, 2, NULL, false); 138 - } 139 - } 140 + ant_value_t then_fn = js_get(js, val, "then"); 141 + if (is_callable(then_fn)) { 142 + ant_value_t then_args[2] = { res_fn, rej_fn }; 143 + ant_value_t then_result = sv_vm_call(js->vm, js, then_fn, val, then_args, 2, NULL, false); 144 + promise_mark_handled(then_result); 145 + }} else { 146 + ant_value_t resolved = js_mkpromise(js); 147 + js_resolve_promise(js, resolved, val); 148 + ant_value_t then_fn = js_get(js, resolved, "then"); 149 + if (is_callable(then_fn)) { 150 + ant_value_t then_args[2] = { res_fn, rej_fn }; 151 + ant_value_t then_result = sv_vm_call(js->vm, js, then_fn, resolved, then_args, 2, NULL, false); 152 + promise_mark_handled(then_result); 153 + }} 140 154 } 141 155 142 156 static void ts_error(ant_t *js, ant_value_t ts_obj, ant_value_t e) { ··· 213 227 ant_value_t writable = ts_writable(ts_obj); 214 228 ws_stream_t *ws = ws_get_stream(writable); 215 229 if (ws && ws->state == WS_STATE_WRITABLE) { 216 - bool had_throw = js->thrown_exists; 217 - ant_value_t saved_value = had_throw ? js->thrown_value : js_mkundef(); 218 - ant_value_t saved_stack = had_throw ? js->thrown_stack : js_mkundef(); 219 - 220 - js_mkerr_typed(js, JS_ERR_TYPE, "TransformStream readable side terminated"); 221 - ant_value_t err = js->thrown_value; 222 - 223 - js->thrown_exists = had_throw; 224 - js->thrown_value = saved_value; 225 - js->thrown_stack = saved_stack; 226 - 230 + ant_value_t err = js_make_error_silent(js, JS_ERR_TYPE, "TransformStream readable side terminated"); 227 231 ts_error_writable_and_unblock_write(js, ts_obj, err); 228 232 } 229 233 } ··· 248 252 ant_value_t transform_fn = ts_ctrl_transform_fn(ctrl_obj); 249 253 ant_value_t ts_obj = ts_ctrl_stream(ctrl_obj); 250 254 ant_value_t p = js_mkpromise(js); 255 + promise_mark_handled(p); 251 256 252 257 if (is_callable(transform_fn)) { 253 258 ant_value_t call_args[2] = { chunk, ctrl_obj }; 254 - ant_value_t result = sv_vm_call(js->vm, js, transform_fn, js_mkundef(), call_args, 2, NULL, false); 259 + ant_value_t result = sv_vm_call(js->vm, js, transform_fn, ts_ctrl_transformer(ctrl_obj), call_args, 2, NULL, false); 255 260 256 261 if (is_err(result)) { 257 - ant_value_t thrown = js->thrown_value; 258 - ant_value_t err = is_object_type(thrown) ? thrown : result; 262 + ant_value_t err = ts_take_thrown_or(js, result); 259 263 ts_error(js, ts_obj, err); 260 264 js_reject_promise(js, p, err); 261 265 return p; ··· 286 290 ant_value_t ctrl_obj = js_get_slot(wrapper, SLOT_DATA); 287 291 ant_value_t chunk = js_get_slot(wrapper, SLOT_ENTRIES); 288 292 ant_value_t ts_obj = js_get_slot(wrapper, SLOT_CTOR); 289 - 290 293 ws_stream_t *ws = ws_get_stream(ts_writable(ts_obj)); 291 294 292 295 if (ws && ws->state == WS_STATE_ERRORING) { 293 - bool had_throw = js->thrown_exists; 294 - ant_value_t saved_value = had_throw ? js->thrown_value : js_mkundef(); 295 - ant_value_t saved_stack = had_throw ? js->thrown_stack : js_mkundef(); 296 - 297 - js_mkerr_typed(js, JS_ERR_TYPE, "WritableStream is in erroring state"); 298 - ant_value_t err = js->thrown_value; 299 - 300 - js->thrown_exists = had_throw; 301 - js->thrown_value = saved_value; 302 - js->thrown_stack = saved_stack; 303 - 296 + ant_value_t err = js_make_error_silent(js, JS_ERR_TYPE, "WritableStream is in erroring state"); 304 297 ant_value_t fp = ts_ctrl_finish_promise(ctrl_obj); 305 298 if (vtype(fp) == T_PROMISE) js_reject_promise(js, fp, err); 306 299 return js_mkundef(); ··· 325 318 ant_value_t ctrl_obj = ts_controller(ts_obj); 326 319 327 320 ant_value_t finish_p = js_mkpromise(js); 321 + promise_mark_handled(finish_p); 328 322 js_set_slot(ctrl_obj, SLOT_RS_PULL, finish_p); 329 323 330 324 if (ts_get_backpressure(ts_obj)) { ··· 360 354 361 355 if (is_callable(cancel_fn)) { 362 356 ant_value_t cancel_args[1] = { reason }; 363 - ant_value_t result = sv_vm_call(js->vm, js, cancel_fn, js_mkundef(), cancel_args, 1, NULL, false); 364 - if (is_err(result)) { 365 - ant_value_t thrown = js->thrown_value; 366 - reason = is_object_type(thrown) ? thrown : reason; 367 - } 357 + ant_value_t result = sv_vm_call(js->vm, js, cancel_fn, ts_ctrl_transformer(ctrl_obj), cancel_args, 1, NULL, false); 358 + if (is_err(result)) reason = ts_take_thrown_or(js, reason); 368 359 } 369 360 370 361 ts_error(js, ts_obj, reason); ··· 380 371 381 372 ant_value_t readable = ts_readable(ts_obj); 382 373 rs_stream_t *rs = rs_get_stream(readable); 383 - if (rs && rs->state == RS_STATE_READABLE) 384 - js_resolve_promise(js, p, js_mkundef()); 374 + if (rs && rs->state == RS_STATE_READABLE) js_resolve_promise(js, p, js_mkundef()); 385 375 else { 386 - bool had_throw = js->thrown_exists; 387 - ant_value_t saved_value = had_throw ? js->thrown_value : js_mkundef(); 388 - ant_value_t saved_stack = had_throw ? js->thrown_stack : js_mkundef(); 389 - 390 - js_mkerr_typed(js, JS_ERR_TYPE, "TransformStream readable side is not in a readable state"); 391 - ant_value_t err = js->thrown_value; 392 - 393 - js->thrown_exists = had_throw; 394 - js->thrown_value = saved_value; 395 - js->thrown_stack = saved_stack; 396 - 376 + ant_value_t err = js_make_error_silent(js, JS_ERR_TYPE, "TransformStream readable side is not in a readable state"); 397 377 js_reject_promise(js, p, err); 398 378 } 399 379 ··· 419 399 ts_ctrl_clear_algorithms(ctrl_obj); 420 400 421 401 ant_value_t p = js_mkpromise(js); 402 + promise_mark_handled(p); 422 403 423 404 if (is_callable(flush_fn)) { 424 405 ant_value_t flush_args[1] = { ctrl_obj }; 425 - ant_value_t result = sv_vm_call(js->vm, js, flush_fn, js_mkundef(), flush_args, 1, NULL, false); 406 + ant_value_t result = sv_vm_call(js->vm, js, flush_fn, ts_ctrl_transformer(ctrl_obj), flush_args, 1, NULL, false); 426 407 427 408 if (is_err(result)) { 428 - ant_value_t thrown = js->thrown_value; 429 - ant_value_t err = is_object_type(thrown) ? thrown : result; 409 + ant_value_t err = ts_take_thrown_or(js, result); 430 410 ts_error(js, ts_obj, err); 431 411 js_reject_promise(js, p, err); 432 412 return p; ··· 487 467 488 468 if (is_callable(cancel_fn)) { 489 469 ant_value_t cancel_args[1] = { reason }; 490 - ant_value_t result = sv_vm_call(js->vm, js, cancel_fn, js_mkundef(), cancel_args, 1, NULL, false); 491 - 492 - if (is_err(result)) { 493 - ant_value_t thrown = js->thrown_value; 494 - reason = is_object_type(thrown) ? thrown : reason; 495 - } else if (ts_is_thenable(js, result)) { 470 + ant_value_t result = sv_vm_call(js->vm, js, cancel_fn, ts_ctrl_transformer(ctrl_obj), cancel_args, 1, NULL, false); 471 + 472 + if (is_err(result)) reason = ts_take_thrown_or(js, reason); 473 + else if (ts_is_thenable(js, result)) { 496 474 ant_value_t p = js_mkpromise(js); 497 475 ant_value_t wrapper = js_mkobj(js); 498 476 js_set_slot(wrapper, SLOT_DATA, p); 499 477 js_set_slot(wrapper, SLOT_ENTRIES, ts_obj); 500 - 478 + 501 479 ant_value_t res_fn = js_heavy_mkfun(js, ts_source_pull_resolve, p); 502 480 ant_value_t rej_fn = js_heavy_mkfun(js, ts_sink_close_reject, wrapper); 503 481 ts_chain_thenable(js, result, res_fn, rej_fn); 504 - 482 + 505 483 ts_error_writable_and_unblock_write(js, ts_obj, reason); 506 484 return p; 507 485 } ··· 707 685 js_set_slot(ctrl_obj, SLOT_ENTRIES, transform_fn); 708 686 js_set_slot(ctrl_obj, SLOT_CTOR, flush_fn); 709 687 js_set_slot(ctrl_obj, SLOT_BUFFER, cancel_fn); 688 + js_set_slot(ctrl_obj, SLOT_SETTLED, transformer); 710 689 js_set_slot(ctrl_obj, SLOT_RS_PULL, js_mkundef()); 711 690 js_set_slot(ts_obj, SLOT_DEFAULT, ctrl_obj); 712 691
+39 -13
src/streams/writable.c
··· 191 191 ant_value_t then_fn = js_get(js, val, "then"); 192 192 if (is_callable(then_fn)) { 193 193 ant_value_t then_args[2] = { res_fn, rej_fn }; 194 - sv_vm_call(js->vm, js, then_fn, val, then_args, 2, NULL, false); 194 + ant_value_t then_result = sv_vm_call(js->vm, js, then_fn, val, then_args, 2, NULL, false); 195 + promise_mark_handled(then_result); 195 196 }} else { 196 197 ant_value_t resolved = js_mkpromise(js); 197 198 js_resolve_promise(js, resolved, val); 198 199 ant_value_t then_fn = js_get(js, resolved, "then"); 199 200 if (is_callable(then_fn)) { 200 201 ant_value_t then_args[2] = { res_fn, rej_fn }; 201 - sv_vm_call(js->vm, js, then_fn, resolved, then_args, 2, NULL, false); 202 + ant_value_t then_result = sv_vm_call(js->vm, js, then_fn, resolved, then_args, 2, NULL, false); 203 + promise_mark_handled(then_result); 202 204 } 203 205 }} 204 206 ··· 229 231 return !is_undefined(iw) || !is_undefined(ic); 230 232 } 231 233 232 - static void ws_writer_ensure_ready_promise_rejected(ant_t *js, ant_value_t writer_obj, ant_value_t error) { 234 + static void ws_writer_replace_ready_promise_rejected(ant_t *js, ant_value_t writer_obj, ant_value_t error) { 233 235 ant_value_t ready = js_mkpromise(js); 234 236 js_reject_promise(js, ready, error); 235 237 promise_mark_handled(ready); 236 238 js_set_slot(writer_obj, SLOT_WS_READY, ready); 237 239 } 238 240 239 - static void ws_writer_ensure_closed_promise_rejected(ant_t *js, ant_value_t writer_obj, ant_value_t error) { 241 + static void ws_writer_replace_closed_promise_rejected(ant_t *js, ant_value_t writer_obj, ant_value_t error) { 240 242 ant_value_t closed = js_mkpromise(js); 241 243 js_reject_promise(js, closed, error); 242 244 promise_mark_handled(closed); 243 245 js_set_slot(writer_obj, SLOT_RS_CLOSED, closed); 244 246 } 245 247 248 + static void ws_writer_reject_ready_promise(ant_t *js, ant_value_t writer_obj, ant_value_t error) { 249 + ant_value_t ready = ws_writer_ready(writer_obj); 250 + if (!is_undefined(ready)) js_reject_promise(js, ready, error); 251 + } 252 + 253 + static void ws_writer_reject_closed_promise(ant_t *js, ant_value_t writer_obj, ant_value_t error) { 254 + ant_value_t closed = ws_writer_closed(writer_obj); 255 + if (!is_undefined(closed)) js_reject_promise(js, closed, error); 256 + } 257 + 246 258 static void writable_stream_start_erroring(ant_t *js, ant_value_t stream_obj, ant_value_t reason) { 247 259 ws_stream_t *stream = ws_get_stream(stream_obj); 248 260 if (!stream || stream->state != WS_STATE_WRITABLE) return; ··· 262 274 263 275 ant_value_t writer_obj = ws_stream_writer(stream_obj); 264 276 if (is_object_type(writer_obj)) 265 - ws_writer_ensure_ready_promise_rejected(js, writer_obj, reason); 277 + ws_writer_reject_ready_promise(js, writer_obj, reason); 266 278 267 279 if (!writable_stream_has_operation_in_flight(stream_obj) && ctrl && ctrl->started) 268 280 writable_stream_finish_erroring(js, stream_obj); ··· 277 289 } 278 290 ant_value_t writer_obj = ws_stream_writer(stream_obj); 279 291 if (is_object_type(writer_obj)) 280 - ws_writer_ensure_closed_promise_rejected(js, writer_obj, stored_error); 292 + ws_writer_reject_closed_promise(js, writer_obj, stored_error); 281 293 } 282 294 283 295 static ant_value_t ws_finish_erroring_abort_resolve(ant_t *js, ant_value_t *args, int nargs) { ··· 384 396 385 397 if (is_object_type(writer_obj) && stream->backpressure != backpressure) { 386 398 if (backpressure) { 387 - js_set_slot(writer_obj, SLOT_WS_READY, js_mkpromise(js)); 399 + ant_value_t ready = js_mkpromise(js); 400 + promise_mark_handled(ready); 401 + js_set_slot(writer_obj, SLOT_WS_READY, ready); 388 402 } else { 389 403 ant_value_t ready = ws_writer_ready(writer_obj); 390 404 if (!is_undefined(ready)) js_resolve_promise(js, ready, js_mkundef()); ··· 689 703 690 704 ant_value_t stored_error = ws_stream_stored_error(stream_obj); 691 705 ant_value_t cr = ws_stream_close_request(stream_obj); 706 + 692 707 if (!is_undefined(cr)) { 693 708 js_reject_promise(js, cr, stored_error); 694 709 js_set_slot(stream_obj, SLOT_WS_CLOSE, js_mkundef()); 695 710 } 711 + 696 712 ant_value_t writer_obj = ws_stream_writer(stream_obj); 697 - if (is_object_type(writer_obj)) 698 - ws_writer_ensure_closed_promise_rejected(js, writer_obj, stored_error); 713 + if (is_object_type(writer_obj)) ws_writer_reject_closed_promise(js, writer_obj, stored_error); 699 714 700 715 return js_mkundef(); 701 716 } ··· 713 728 714 729 ant_value_t stored_error = ws_stream_stored_error(stream_obj); 715 730 ant_value_t cr = ws_stream_close_request(stream_obj); 731 + 716 732 if (!is_undefined(cr)) { 717 733 js_reject_promise(js, cr, stored_error); 718 734 js_set_slot(stream_obj, SLOT_WS_CLOSE, js_mkundef()); 719 735 } 736 + 720 737 ant_value_t writer_obj = ws_stream_writer(stream_obj); 721 738 if (is_object_type(writer_obj)) 722 - ws_writer_ensure_closed_promise_rejected(js, writer_obj, stored_error); 739 + ws_writer_reject_closed_promise(js, writer_obj, stored_error); 723 740 724 741 return js_mkundef(); 725 742 } ··· 920 937 static ant_value_t js_ws_writer_release_lock(ant_t *js, ant_value_t *args, int nargs) { 921 938 ant_value_t stream_obj = ws_writer_stream(js->this_val); 922 939 if (!is_object_type(stream_obj)) return js_mkundef(); 923 - 924 940 ant_value_t release_err = js_make_error_silent(js, JS_ERR_TYPE, "Writer was released"); 925 941 926 - ws_writer_ensure_ready_promise_rejected(js, js->this_val, release_err); 927 - ws_writer_ensure_closed_promise_rejected(js, js->this_val, release_err); 942 + ws_writer_reject_ready_promise(js, js->this_val, release_err); 943 + ws_writer_reject_closed_promise(js, js->this_val, release_err); 944 + 945 + promise_mark_handled(ws_writer_ready(js->this_val)); 946 + promise_mark_handled(ws_writer_closed(js->this_val)); 947 + 948 + ws_writer_replace_ready_promise_rejected(js, js->this_val, release_err); 949 + ws_writer_replace_closed_promise_rejected(js, js->this_val, release_err); 928 950 929 951 js_set_slot(stream_obj, SLOT_CTOR, js_mkundef()); 930 952 js_set_slot(js->this_val, SLOT_ENTRIES, js_mkundef()); 953 + 931 954 return js_mkundef(); 932 955 } 933 956 ··· 964 987 965 988 ant_value_t closed = js_mkpromise(js); 966 989 ant_value_t ready = js_mkpromise(js); 990 + 991 + promise_mark_handled(closed); 992 + promise_mark_handled(ready); 967 993 968 994 js_set_slot(obj, SLOT_ENTRIES, stream_obj); 969 995 js_set_slot(obj, SLOT_RS_CLOSED, closed);