Skip to content

Commit 327b072

Browse files
michaelficarramichaelficarra
committed
update polyfill and tests to match spec text
1 parent 41d8d85 commit 327b072

File tree

2 files changed

+143
-80
lines changed

2 files changed

+143
-80
lines changed

‎src/index.ts‎

Lines changed: 11 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ function chunks(this: unknown, chunkSize: unknown): Generator<unknown> {
3131
return chunksImpl(this as Iterator<unknown>, chunkSize)
3232
}
3333

34-
function* windowsImpl<A>(iter: Iterator<A>, windowSize: number): Generator<Array<A>> {
34+
function* windowsImpl<A>(iter: Iterator<A>, windowSize: number, undersized: 'only full' | 'allow partial'): Generator<Array<A>> {
3535
let buffer = [];
3636
for (const elem of liftIterator(iter)) {
3737
if (buffer.length === windowSize) {
@@ -42,39 +42,13 @@ function* windowsImpl<A>(iter: Iterator<A>, windowSize: number): Generator<Array
4242
yield buffer.slice();
4343
}
4444
}
45-
}
46-
47-
function windows<A>(this: Iterator<A>, windowSize: number): Generator<Array<A>>
48-
function windows(this: unknown, windowSize: unknown): Generator<unknown> {
49-
if (
50-
typeof windowSize !== 'number'
51-
|| windowSize <= 0
52-
|| Math.floor(windowSize) !== windowSize
53-
|| windowSize >= Math.pow(2, 53)
54-
) {
55-
throw new RangeError;
56-
}
57-
return windowsImpl(this as Iterator<unknown>, windowSize);
58-
}
59-
60-
function* slidingImpl<A>(iter: Iterator<A>, windowSize: number): Generator<Array<A>> {
61-
let buffer = [];
62-
for (const elem of liftIterator(iter)) {
63-
if (buffer.length === windowSize) {
64-
buffer.shift();
65-
}
66-
buffer.push(elem);
67-
if (buffer.length === windowSize) {
68-
yield buffer.slice();
69-
}
70-
}
71-
if (0 < buffer.length && buffer.length < windowSize) {
45+
if (undersized === 'allow partial' && 0 < buffer.length && buffer.length < windowSize) {
7246
yield buffer;
7347
}
7448
}
7549

76-
function sliding<A>(this: Iterator<A>, windowSize: number): Generator<Array<A>>
77-
function sliding(this: unknown, windowSize: unknown): Generator<unknown> {
50+
function windows<A>(this: Iterator<A>, windowSize: number, undersized?: 'only full' | 'allow partial'): Generator<Array<A>>
51+
function windows(this: unknown, windowSize: unknown, undersized?: unknown): Generator<unknown> {
7852
if (
7953
typeof windowSize !== 'number'
8054
|| windowSize <= 0
@@ -83,7 +57,13 @@ function sliding(this: unknown, windowSize: unknown): Generator<unknown> {
8357
) {
8458
throw new RangeError;
8559
}
86-
return slidingImpl(this as Iterator<unknown>, windowSize);
60+
if (undersized === undefined) {
61+
undersized = 'only full';
62+
}
63+
if (undersized !== 'only full' && undersized !== 'allow partial') {
64+
throw new TypeError;
65+
}
66+
return windowsImpl(this as Iterator<unknown>, windowSize, undersized);
8767
}
8868

8969
Object.defineProperty(IteratorPrototype, 'chunks', {
@@ -99,10 +79,3 @@ Object.defineProperty(IteratorPrototype, 'windows', {
9979
enumerable: false,
10080
value: windows,
10181
});
102-
103-
Object.defineProperty(IteratorPrototype, 'sliding', {
104-
configurable: true,
105-
writable: true,
106-
enumerable: false,
107-
value: sliding,
108-
});

‎test/index.mjs‎

Lines changed: 132 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -61,81 +61,171 @@ test('windows', async t => {
6161
Array.from(nats(5).windows(2)),
6262
[[0, 1], [1, 2], [2, 3], [3, 4]],
6363
);
64+
assert.deepEqual(
65+
Array.from(nats(5).windows(2, undefined)),
66+
[[0, 1], [1, 2], [2, 3], [3, 4]],
67+
);
68+
assert.deepEqual(
69+
Array.from(nats(5).windows(2, "only full")),
70+
[[0, 1], [1, 2], [2, 3], [3, 4]],
71+
);
72+
assert.deepEqual(
73+
Array.from(nats(5).windows(2, "allow partial")),
74+
[[0, 1], [1, 2], [2, 3], [3, 4]],
75+
);
76+
6477
assert.deepEqual(
6578
Array.from(nats(5).windows(1)),
6679
[[0], [1], [2], [3], [4]],
6780
);
81+
assert.deepEqual(
82+
Array.from(nats(5).windows(1, undefined)),
83+
[[0], [1], [2], [3], [4]],
84+
);
85+
assert.deepEqual(
86+
Array.from(nats(5).windows(1, "only full")),
87+
[[0], [1], [2], [3], [4]],
88+
);
89+
assert.deepEqual(
90+
Array.from(nats(5).windows(1, "allow partial")),
91+
[[0], [1], [2], [3], [4]],
92+
);
93+
6894
assert.deepEqual(
6995
Array.from(nats(6).windows(3)),
7096
[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]],
7197
);
98+
assert.deepEqual(
99+
Array.from(nats(6).windows(3, undefined)),
100+
[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]],
101+
);
102+
assert.deepEqual(
103+
Array.from(nats(6).windows(3, "only full")),
104+
[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]],
105+
);
106+
assert.deepEqual(
107+
Array.from(nats(6).windows(3, "allow partial")),
108+
[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]],
109+
);
110+
72111
assert.deepEqual(
73112
Array.from(nats(6).windows(100)),
74113
[],
75114
);
115+
assert.deepEqual(
116+
Array.from(nats(6).windows(100, undefined)),
117+
[],
118+
);
119+
assert.deepEqual(
120+
Array.from(nats(6).windows(100, "only full")),
121+
[],
122+
);
123+
assert.deepEqual(
124+
Array.from(nats(6).windows(100, "allow partial")),
125+
[[0, 1, 2, 3, 4, 5]],
126+
);
127+
76128
assert.deepEqual(
77129
Array.from(nats(0).windows(2)),
78130
[],
79131
);
132+
assert.deepEqual(
133+
Array.from(nats(0).windows(2, undefined)),
134+
[],
135+
);
136+
assert.deepEqual(
137+
Array.from(nats(0).windows(2, "only full")),
138+
[],
139+
);
140+
assert.deepEqual(
141+
Array.from(nats(0).windows(2, "allow partial")),
142+
[],
143+
);
80144

81145
assert.throws(() => {
82146
nats(1).windows()
83-
}, RangeError)
147+
}, RangeError);
148+
assert.throws(() => {
149+
nats(1).windows(undefined, "only full")
150+
}, RangeError);
151+
assert.throws(() => {
152+
nats(1).windows(undefined, "allow partial")
153+
}, RangeError);
154+
84155
assert.throws(() => {
85156
nats(1).windows([2]);
86-
}, RangeError)
157+
}, RangeError);
158+
assert.throws(() => {
159+
nats(1).windows([2], "only full");
160+
}, RangeError);
161+
assert.throws(() => {
162+
nats(1).windows([2], "allow partial");
163+
}, RangeError);
164+
87165
assert.throws(() => {
88166
nats(1).windows(0);
89-
}, RangeError)
167+
}, RangeError);
168+
assert.throws(() => {
169+
nats(1).windows(0, undefined);
170+
}, RangeError);
171+
assert.throws(() => {
172+
nats(1).windows(0, "only full");
173+
}, RangeError);
174+
assert.throws(() => {
175+
nats(1).windows(0, "allow partial");
176+
}, RangeError);
177+
90178
assert.throws(() => {
91179
nats(1).windows(-1);
92-
}, RangeError)
180+
}, RangeError);
93181
assert.throws(() => {
94-
nats(1).windows(1.5);
95-
}, RangeError)
182+
nats(1).windows(-1, undefined);
183+
}, RangeError);
96184
assert.throws(() => {
97-
nats(1).windows(Math.pow(2, 53));
98-
}, RangeError)
99-
});
185+
nats(1).windows(-1, "only full");
186+
}, RangeError);
187+
assert.throws(() => {
188+
nats(1).windows(-1, "allow partial");
189+
}, RangeError);
100190

101-
test('sliding', async t => {
102-
assert.deepEqual(
103-
Array.from(nats(5).sliding(2)),
104-
[[0, 1], [1, 2], [2, 3], [3, 4]],
105-
);
106-
assert.deepEqual(
107-
Array.from(nats(5).sliding(1)),
108-
[[0], [1], [2], [3], [4]],
109-
);
110-
assert.deepEqual(
111-
Array.from(nats(6).sliding(3)),
112-
[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]],
113-
);
114-
assert.deepEqual(
115-
Array.from(nats(6).sliding(100)),
116-
[[0, 1, 2, 3, 4, 5]],
117-
);
118-
assert.deepEqual(
119-
Array.from(nats(0).sliding(2)),
120-
[],
121-
);
191+
assert.throws(() => {
192+
nats(1).windows(1.5);
193+
}, RangeError);
194+
assert.throws(() => {
195+
nats(1).windows(1.5, undefined);
196+
}, RangeError);
197+
assert.throws(() => {
198+
nats(1).windows(1.5, "only full");
199+
}, RangeError);
200+
assert.throws(() => {
201+
nats(1).windows(1.5, "allow partial");
202+
}, RangeError);
122203

123204
assert.throws(() => {
124-
nats(1).sliding()
125-
}, RangeError)
205+
nats(1).windows(Math.pow(2, 53));
206+
}, RangeError);
126207
assert.throws(() => {
127-
nats(1).sliding([2]);
128-
}, RangeError)
208+
nats(1).windows(Math.pow(2, 53), undefined);
209+
}, RangeError);
129210
assert.throws(() => {
130-
nats(1).sliding(0);
131-
}, RangeError)
211+
nats(1).windows(Math.pow(2, 53), "only full");
212+
}, RangeError);
132213
assert.throws(() => {
133-
nats(1).sliding(-1);
134-
}, RangeError)
214+
nats(1).windows(Math.pow(2, 53), "allow partial");
215+
}, RangeError);
216+
135217
assert.throws(() => {
136-
nats(1).sliding(1.5);
137-
}, RangeError)
218+
nats(1).windows(1, "something else");
219+
}, TypeError);
138220
assert.throws(() => {
139-
nats(1).sliding(Math.pow(2, 53));
140-
}, RangeError)
221+
nats(1).windows(1, "");
222+
}, TypeError);
223+
assert.throws(() => {
224+
nats(1).windows(1, null);
225+
}, TypeError);
226+
227+
assert.throws(() => {
228+
nats(1).windows(0, "something else");
229+
}, RangeError);
230+
141231
});

0 commit comments

Comments
 (0)