Debian Codegraph @

jridgewell-resolve-uri/test/resolve/with-hash-base.test.js

raw
1 const resolve = require('../..');
2 const assert = require('assert');
3
4 describe('with hash base', () => {
5 describe(`base = "#baseHash"`, () => {
6 describe('with absolute input', () => {
7 it('returns input', () => {
8 const base = '#baseHash';
9 const input = 'https://absolute.com/main.js.map';
10 const resolved = resolve(input, base);
11 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
12 });
13
14 it('returns input with query', () => {
15 const base = '#baseHash';
16 const input = 'https://absolute.com/main.js.map?input';
17 const resolved = resolve(input, base);
18 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
19 });
20
21 it('normalizes input path', () => {
22 const base = '#baseHash';
23 const input = 'https://absolute.com/foo/./bar/../main.js.map';
24 const resolved = resolve(input, base);
25 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
26 });
27
28 it('normalizes input path with query', () => {
29 const base = '#baseHash';
30 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
31 const resolved = resolve(input, base);
32 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
33 });
34
35 it('normalizes pathless input', () => {
36 const base = '#baseHash';
37 const input = 'https://absolute.com';
38 const resolved = resolve(input, base);
39 assert.strictEqual(resolved, 'https://absolute.com/');
40 });
41
42 it('normalizes pathless input with query', () => {
43 const base = '#baseHash';
44 const input = 'https://absolute.com?input';
45 const resolved = resolve(input, base);
46 assert.strictEqual(resolved, 'https://absolute.com/?input');
47 });
48
49 it('normalizes current directory', () => {
50 const base = '#baseHash';
51 const input = 'https://absolute.com/./main.js.map';
52 const resolved = resolve(input, base);
53 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
54 });
55
56 it('normalizes too many parent accessors', () => {
57 const base = '#baseHash';
58 const input = 'https://absolute.com/../../../main.js.map';
59 const resolved = resolve(input, base);
60 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
61 });
62
63 it('normalizes too many parent accessors, late', () => {
64 const base = '#baseHash';
65 const input = 'https://absolute.com/foo/../../../main.js.map';
66 const resolved = resolve(input, base);
67 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
68 });
69
70 it('normalizes file protocol 1', () => {
71 const base = '#baseHash';
72 const input = 'file:///root/main.js.map';
73 const resolved = resolve(input, base);
74 assert.strictEqual(resolved, 'file:///root/main.js.map');
75 });
76
77 it('normalizes file protocol 2', () => {
78 const base = '#baseHash';
79 const input = 'file://root/main.js.map';
80 const resolved = resolve(input, base);
81 assert.strictEqual(resolved, 'file://root/main.js.map');
82 });
83
84 it('normalizes file protocol 2.5', () => {
85 const base = '#baseHash';
86 const input = 'file://root';
87 const resolved = resolve(input, base);
88 assert.strictEqual(resolved, 'file://root/');
89 });
90
91 it('normalizes file protocol 3', () => {
92 const base = '#baseHash';
93 const input = 'file:/root/main.js.map';
94 const resolved = resolve(input, base);
95 assert.strictEqual(resolved, 'file:///root/main.js.map');
96 });
97
98 it('normalizes file protocol 4', () => {
99 const base = '#baseHash';
100 const input = 'file:root/main.js.map';
101 const resolved = resolve(input, base);
102 assert.strictEqual(resolved, 'file:///root/main.js.map');
103 });
104
105 it('normalizes file protocol 1 with query', () => {
106 const base = '#baseHash';
107 const input = 'file:///root/main.js.map?input';
108 const resolved = resolve(input, base);
109 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
110 });
111
112 it('normalizes file protocol 2 with query', () => {
113 const base = '#baseHash';
114 const input = 'file://root/main.js.map?input';
115 const resolved = resolve(input, base);
116 assert.strictEqual(resolved, 'file://root/main.js.map?input');
117 });
118
119 it('normalizes file protocol 2.5 with query', () => {
120 const base = '#baseHash';
121 const input = 'file://root?input';
122 const resolved = resolve(input, base);
123 assert.strictEqual(resolved, 'file://root/?input');
124 });
125
126 it('normalizes file protocol 3 with query', () => {
127 const base = '#baseHash';
128 const input = 'file:/root/main.js.map?input';
129 const resolved = resolve(input, base);
130 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
131 });
132
133 it('normalizes file protocol 4 with query', () => {
134 const base = '#baseHash';
135 const input = 'file:root/main.js.map?input';
136 const resolved = resolve(input, base);
137 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
138 });
139 });
140
141 describe('with protocol relative input', () => {
142 it('resolves relative to the base protocol', () => {
143 const base = '#baseHash';
144 const input = '//protocol-relative.com/main.js.map';
145 const resolved = resolve(input, base);
146 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
147 });
148
149 it('resolves relative to the base protocol with query', () => {
150 const base = '#baseHash';
151 const input = '//protocol-relative.com/main.js.map?input';
152 const resolved = resolve(input, base);
153 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
154 });
155
156 it('normalizes input path', () => {
157 const base = '#baseHash';
158 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
159 const resolved = resolve(input, base);
160 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
161 });
162
163 it('normalizes input path with query', () => {
164 const base = '#baseHash';
165 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
166 const resolved = resolve(input, base);
167 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
168 });
169
170 it('normalizes pathless input', () => {
171 const base = '#baseHash';
172 const input = '//protocol-relative.com';
173 const resolved = resolve(input, base);
174 assert.strictEqual(resolved, '//protocol-relative.com/');
175 });
176
177 it('normalizes pathless input with query', () => {
178 const base = '#baseHash';
179 const input = '//protocol-relative.com?input';
180 const resolved = resolve(input, base);
181 assert.strictEqual(resolved, '//protocol-relative.com/?input');
182 });
183
184 it('normalizes current directory', () => {
185 const base = '#baseHash';
186 const input = '//protocol-relative.com/./main.js.map';
187 const resolved = resolve(input, base);
188 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
189 });
190
191 it('normalizes too many parent accessors', () => {
192 const base = '#baseHash';
193 const input = '//protocol-relative.com/../main.js.map';
194 const resolved = resolve(input, base);
195 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
196 });
197
198 it('normalizes too many parent accessors, late', () => {
199 const base = '#baseHash';
200 const input = '//protocol-relative.com/foo/../../main.js.map';
201 const resolved = resolve(input, base);
202 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
203 });
204 });
205
206 describe('with absolute path input', () => {
207 it('remains absolute path', () => {
208 const base = '#baseHash';
209 const input = '/assets/main.js.map';
210 const resolved = resolve(input, base);
211 assert.strictEqual(resolved, '/assets/main.js.map');
212 });
213
214 it('remains absolute path with query', () => {
215 const base = '#baseHash';
216 const input = '/assets/main.js.map?input';
217 const resolved = resolve(input, base);
218 assert.strictEqual(resolved, '/assets/main.js.map?input');
219 });
220
221 it('trims to root', () => {
222 const base = '#baseHash';
223 const input = '/';
224 const resolved = resolve(input, base);
225 assert.strictEqual(resolved, '/');
226 });
227
228 it('normalizes input path', () => {
229 const base = '#baseHash';
230 const input = '/foo/./bar/../main.js.map';
231 const resolved = resolve(input, base);
232 assert.strictEqual(resolved, '/foo/main.js.map');
233 });
234
235 it('normalizes current directory', () => {
236 const base = '#baseHash';
237 const input = '/./main.js.map';
238 const resolved = resolve(input, base);
239 assert.strictEqual(resolved, '/main.js.map');
240 });
241
242 it('normalizes too many parent accessors', () => {
243 const base = '#baseHash';
244 const input = '/../../../main.js.map';
245 const resolved = resolve(input, base);
246 assert.strictEqual(resolved, '/main.js.map');
247 });
248
249 it('normalizes too many parent accessors with query 1', () => {
250 const base = '#baseHash';
251 const input = '/../../../?input';
252 const resolved = resolve(input, base);
253 assert.strictEqual(resolved, '/?input');
254 });
255
256 it('normalizes too many parent accessors with query 2', () => {
257 const base = '#baseHash';
258 const input = '/../../..?input';
259 const resolved = resolve(input, base);
260 assert.strictEqual(resolved, '/?input');
261 });
262
263 it('normalizes too many parent accessors, late', () => {
264 const base = '#baseHash';
265 const input = '/foo/../../../main.js.map';
266 const resolved = resolve(input, base);
267 assert.strictEqual(resolved, '/main.js.map');
268 });
269 });
270
271 describe('with leading dot relative input', () => {
272 it('resolves relative to current directory', () => {
273 const base = '#baseHash';
274 const input = './bar/main.js.map';
275 const resolved = resolve(input, base);
276 assert.strictEqual(resolved, './bar/main.js.map');
277 });
278
279 it('resolves relative to current directory with query', () => {
280 const base = '#baseHash';
281 const input = './bar/main.js.map?input';
282 const resolved = resolve(input, base);
283 assert.strictEqual(resolved, './bar/main.js.map?input');
284 });
285
286 it('resolves relative to parent directory', () => {
287 const base = '#baseHash';
288 const input = '../bar/main.js.map';
289 const resolved = resolve(input, base);
290 assert.strictEqual(resolved, '../bar/main.js.map');
291 });
292
293 it('resolves relative to parent directory with query', () => {
294 const base = '#baseHash';
295 const input = '../bar/main.js.map?input';
296 const resolved = resolve(input, base);
297 assert.strictEqual(resolved, '../bar/main.js.map?input');
298 });
299
300 it('resolves relative to parent multiple directory', () => {
301 const base = '#baseHash';
302 const input = '../../../bar/main.js.map';
303 const resolved = resolve(input, base);
304 assert.strictEqual(resolved, '../../../bar/main.js.map');
305 });
306
307 it('resolves relative to parent multiple directory with query 1', () => {
308 const base = '#baseHash';
309 const input = '../../../?input';
310 const resolved = resolve(input, base);
311 assert.strictEqual(resolved, '../../..?input');
312 });
313
314 it('resolves relative to parent multiple directory with query 2', () => {
315 const base = '#baseHash';
316 const input = '../../..?input';
317 const resolved = resolve(input, base);
318 assert.strictEqual(resolved, '../../..?input');
319 });
320
321 it('normalizes input path', () => {
322 const base = '#baseHash';
323 const input = './foo/./bar/../main.js.map';
324 const resolved = resolve(input, base);
325 assert.strictEqual(resolved, './foo/main.js.map');
326 });
327 });
328
329 describe('with relative path input', () => {
330 it('resolves relative to current directory', () => {
331 const base = '#baseHash';
332 const input = 'bar/main.js.map';
333 const resolved = resolve(input, base);
334 assert.strictEqual(resolved, './bar/main.js.map');
335 });
336
337 it('resolves relative to current directory with query', () => {
338 const base = '#baseHash';
339 const input = 'bar/main.js.map?input';
340 const resolved = resolve(input, base);
341 assert.strictEqual(resolved, './bar/main.js.map?input');
342 });
343
344 it('resolves relative to parent multiple directory, later', () => {
345 const base = '#baseHash';
346 const input = 'foo/../../../bar/main.js.map';
347 const resolved = resolve(input, base);
348 assert.strictEqual(resolved, '../../bar/main.js.map');
349 });
350
351 it('normalizes input path', () => {
352 const base = '#baseHash';
353 const input = 'foo/./bar/../main.js.map';
354 const resolved = resolve(input, base);
355 assert.strictEqual(resolved, './foo/main.js.map');
356 });
357
358 it('resolves node_module scope as path', () => {
359 const base = '#baseHash';
360 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
361 const resolved = resolve(input, base);
362 assert.strictEqual(resolved, './node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
363 });
364
365 it('resolves package scope as path', () => {
366 const base = '#baseHash';
367 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
368 const resolved = resolve(input, base);
369 assert.strictEqual(resolved, './@babel/runtime/helpers/esm/arrayLikeToArray.js');
370 });
371 });
372
373 describe('with query input', () => {
374 it('resolves relative to path', () => {
375 const base = '#baseHash';
376 const input = '?input';
377 const resolved = resolve(input, base);
378 assert.strictEqual(resolved, '?input');
379 });
380 });
381
382 describe('with hash input', () => {
383 it('resolves relative to path', () => {
384 const base = '#baseHash';
385 const input = '#input';
386 const resolved = resolve(input, base);
387 assert.strictEqual(resolved, '#input');
388 });
389 });
390
391 describe('empty input', () => {
392 it('normalizes base', () => {
393 const base = '#baseHash';
394 const input = '';
395 const resolved = resolve(input, base);
396 assert.strictEqual(resolved, '#baseHash');
397 });
398 });
399 });
400 });