• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1'use strict';
2
3self.recordingReadableStream = (extras = {}, strategy) => {
4  let controllerToCopyOver;
5  const stream = new ReadableStream({
6    type: extras.type,
7    start(controller) {
8      controllerToCopyOver = controller;
9
10      if (extras.start) {
11        return extras.start(controller);
12      }
13
14      return undefined;
15    },
16    pull(controller) {
17      stream.events.push('pull');
18
19      if (extras.pull) {
20        return extras.pull(controller);
21      }
22
23      return undefined;
24    },
25    cancel(reason) {
26      stream.events.push('cancel', reason);
27      stream.eventsWithoutPulls.push('cancel', reason);
28
29      if (extras.cancel) {
30        return extras.cancel(reason);
31      }
32
33      return undefined;
34    }
35  }, strategy);
36
37  stream.controller = controllerToCopyOver;
38  stream.events = [];
39  stream.eventsWithoutPulls = [];
40
41  return stream;
42};
43
44self.recordingWritableStream = (extras = {}, strategy) => {
45  let controllerToCopyOver;
46  const stream = new WritableStream({
47    start(controller) {
48      controllerToCopyOver = controller;
49
50      if (extras.start) {
51        return extras.start(controller);
52      }
53
54      return undefined;
55    },
56    write(chunk, controller) {
57      stream.events.push('write', chunk);
58
59      if (extras.write) {
60        return extras.write(chunk, controller);
61      }
62
63      return undefined;
64    },
65    close() {
66      stream.events.push('close');
67
68      if (extras.close) {
69        return extras.close();
70      }
71
72      return undefined;
73    },
74    abort(e) {
75      stream.events.push('abort', e);
76
77      if (extras.abort) {
78        return extras.abort(e);
79      }
80
81      return undefined;
82    }
83  }, strategy);
84
85  stream.controller = controllerToCopyOver;
86  stream.events = [];
87
88  return stream;
89};
90
91self.recordingTransformStream = (extras = {}, writableStrategy, readableStrategy) => {
92  let controllerToCopyOver;
93  const stream = new TransformStream({
94    start(controller) {
95      controllerToCopyOver = controller;
96
97      if (extras.start) {
98        return extras.start(controller);
99      }
100
101      return undefined;
102    },
103
104    transform(chunk, controller) {
105      stream.events.push('transform', chunk);
106
107      if (extras.transform) {
108        return extras.transform(chunk, controller);
109      }
110
111      controller.enqueue(chunk);
112
113      return undefined;
114    },
115
116    flush(controller) {
117      stream.events.push('flush');
118
119      if (extras.flush) {
120        return extras.flush(controller);
121      }
122
123      return undefined;
124    }
125  }, writableStrategy, readableStrategy);
126
127  stream.controller = controllerToCopyOver;
128  stream.events = [];
129
130  return stream;
131};
132