MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
TransformStream
+137
-94
+5
-3
examples/spec/streams-transform.js
+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
+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
+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
+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
+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);