CoCalc -- test-source-map-consumer.js

Summer of Sage Days 2015: San Diego (sd64.25), etc.
react / wstein / node_modules / browserify / node_modules / insert-module-globals / node_modules / combine-source-map / node_modules / inline-source-map / node_modules / source-map / test / source-map / test-source-map-consumer.js
⁸⁰⁶²⁰ views
1
/* -*- Mode: js; js-indent-level: 2; -*- */
2
/*
3
 * Copyright 2011 Mozilla Foundation and contributors
4
 * Licensed under the New BSD license. See LICENSE or:
5
 * http://opensource.org/licenses/BSD-3-Clause
6
 */
7
if (typeof define !== 'function') {
8
    var define = require('amdefine')(module, require);
9
}
10
define(function (require, exports, module) {
11

12
  var SourceMapConsumer = require('../../lib/source-map/source-map-consumer').SourceMapConsumer;
13
  var IndexedSourceMapConsumer = require('../../lib/source-map/indexed-source-map-consumer').IndexedSourceMapConsumer;
14
  var BasicSourceMapConsumer = require('../../lib/source-map/basic-source-map-consumer').BasicSourceMapConsumer;
15
  var SourceMapGenerator = require('../../lib/source-map/source-map-generator').SourceMapGenerator;
16

17
  exports['test that we can instantiate with a string or an object'] = function (assert, util) {
18
    assert.doesNotThrow(function () {
19
      var map = new SourceMapConsumer(util.testMap);
20
    });
21
    assert.doesNotThrow(function () {
22
      var map = new SourceMapConsumer(JSON.stringify(util.testMap));
23
    });
24
  };
25

26
  exports['test that the object returned from new SourceMapConsumer inherits from SourceMapConsumer'] = function (assert, util) {
27
    assert.ok(new SourceMapConsumer(util.testMap) instanceof SourceMapConsumer);
28
  }
29

30
  exports['test that a BasicSourceMapConsumer is returned for sourcemaps without sections'] = function(assert, util) {
31
    assert.ok(new SourceMapConsumer(util.testMap) instanceof BasicSourceMapConsumer);
32
  };
33

34
  exports['test that an IndexedSourceMapConsumer is returned for sourcemaps with sections'] = function(assert, util) {
35
    assert.ok(new SourceMapConsumer(util.indexedTestMap) instanceof IndexedSourceMapConsumer);
36
  };
37

38
  exports['test that the `sources` field has the original sources'] = function (assert, util) {
39
    var map;
40
    var sources;
41

42
    map = new SourceMapConsumer(util.testMap);
43
    sources = map.sources;
44
    assert.equal(sources[0], '/the/root/one.js');
45
    assert.equal(sources[1], '/the/root/two.js');
46
    assert.equal(sources.length, 2);
47

48
    map = new SourceMapConsumer(util.indexedTestMap);
49
    sources = map.sources;
50
    assert.equal(sources[0], '/the/root/one.js');
51
    assert.equal(sources[1], '/the/root/two.js');
52
    assert.equal(sources.length, 2);
53

54
    map = new SourceMapConsumer(util.indexedTestMapDifferentSourceRoots);
55
    sources = map.sources;
56
    assert.equal(sources[0], '/the/root/one.js');
57
    assert.equal(sources[1], '/different/root/two.js');
58
    assert.equal(sources.length, 2);
59

60
    map = new SourceMapConsumer(util.testMapNoSourceRoot);
61
    sources = map.sources;
62
    assert.equal(sources[0], 'one.js');
63
    assert.equal(sources[1], 'two.js');
64
    assert.equal(sources.length, 2);
65

66
    map = new SourceMapConsumer(util.testMapEmptySourceRoot);
67
    sources = map.sources;
68
    assert.equal(sources[0], 'one.js');
69
    assert.equal(sources[1], 'two.js');
70
    assert.equal(sources.length, 2);
71
  };
72

73
  exports['test that the source root is reflected in a mapping\'s source field'] = function (assert, util) {
74
    var map;
75
    var mapping;
76

77
    map = new SourceMapConsumer(util.testMap);
78

79
    mapping = map.originalPositionFor({
80
      line: 2,
81
      column: 1
82
    });
83
    assert.equal(mapping.source, '/the/root/two.js');
84

85
    mapping = map.originalPositionFor({
86
      line: 1,
87
      column: 1
88
    });
89
    assert.equal(mapping.source, '/the/root/one.js');
90

91

92
    map = new SourceMapConsumer(util.testMapNoSourceRoot);
93

94
    mapping = map.originalPositionFor({
95
      line: 2,
96
      column: 1
97
    });
98
    assert.equal(mapping.source, 'two.js');
99

100
    mapping = map.originalPositionFor({
101
      line: 1,
102
      column: 1
103
    });
104
    assert.equal(mapping.source, 'one.js');
105

106

107
    map = new SourceMapConsumer(util.testMapEmptySourceRoot);
108

109
    mapping = map.originalPositionFor({
110
      line: 2,
111
      column: 1
112
    });
113
    assert.equal(mapping.source, 'two.js');
114

115
    mapping = map.originalPositionFor({
116
      line: 1,
117
      column: 1
118
    });
119
    assert.equal(mapping.source, 'one.js');
120
  };
121

122
  exports['test mapping tokens back exactly'] = function (assert, util) {
123
    var map = new SourceMapConsumer(util.testMap);
124

125
    util.assertMapping(1, 1, '/the/root/one.js', 1, 1, null, map, assert);
126
    util.assertMapping(1, 5, '/the/root/one.js', 1, 5, null, map, assert);
127
    util.assertMapping(1, 9, '/the/root/one.js', 1, 11, null, map, assert);
128
    util.assertMapping(1, 18, '/the/root/one.js', 1, 21, 'bar', map, assert);
129
    util.assertMapping(1, 21, '/the/root/one.js', 2, 3, null, map, assert);
130
    util.assertMapping(1, 28, '/the/root/one.js', 2, 10, 'baz', map, assert);
131
    util.assertMapping(1, 32, '/the/root/one.js', 2, 14, 'bar', map, assert);
132

133
    util.assertMapping(2, 1, '/the/root/two.js', 1, 1, null, map, assert);
134
    util.assertMapping(2, 5, '/the/root/two.js', 1, 5, null, map, assert);
135
    util.assertMapping(2, 9, '/the/root/two.js', 1, 11, null, map, assert);
136
    util.assertMapping(2, 18, '/the/root/two.js', 1, 21, 'n', map, assert);
137
    util.assertMapping(2, 21, '/the/root/two.js', 2, 3, null, map, assert);
138
    util.assertMapping(2, 28, '/the/root/two.js', 2, 10, 'n', map, assert);
139
  };
140

141
  exports['test mapping tokens back exactly in indexed source map'] = function (assert, util) {
142
    var map = new SourceMapConsumer(util.indexedTestMap);
143

144
    util.assertMapping(1, 1, '/the/root/one.js', 1, 1, null, map, assert);
145
    util.assertMapping(1, 5, '/the/root/one.js', 1, 5, null, map, assert);
146
    util.assertMapping(1, 9, '/the/root/one.js', 1, 11, null, map, assert);
147
    util.assertMapping(1, 18, '/the/root/one.js', 1, 21, 'bar', map, assert);
148
    util.assertMapping(1, 21, '/the/root/one.js', 2, 3, null, map, assert);
149
    util.assertMapping(1, 28, '/the/root/one.js', 2, 10, 'baz', map, assert);
150
    util.assertMapping(1, 32, '/the/root/one.js', 2, 14, 'bar', map, assert);
151

152
    util.assertMapping(2, 1, '/the/root/two.js', 1, 1, null, map, assert);
153
    util.assertMapping(2, 5, '/the/root/two.js', 1, 5, null, map, assert);
154
    util.assertMapping(2, 9, '/the/root/two.js', 1, 11, null, map, assert);
155
    util.assertMapping(2, 18, '/the/root/two.js', 1, 21, 'n', map, assert);
156
    util.assertMapping(2, 21, '/the/root/two.js', 2, 3, null, map, assert);
157
    util.assertMapping(2, 28, '/the/root/two.js', 2, 10, 'n', map, assert);
158
  };
159

160

161
  exports['test mapping tokens back exactly'] = function (assert, util) {
162
    var map = new SourceMapConsumer(util.testMap);
163

164
    util.assertMapping(1, 1, '/the/root/one.js', 1, 1, null, map, assert);
165
    util.assertMapping(1, 5, '/the/root/one.js', 1, 5, null, map, assert);
166
    util.assertMapping(1, 9, '/the/root/one.js', 1, 11, null, map, assert);
167
    util.assertMapping(1, 18, '/the/root/one.js', 1, 21, 'bar', map, assert);
168
    util.assertMapping(1, 21, '/the/root/one.js', 2, 3, null, map, assert);
169
    util.assertMapping(1, 28, '/the/root/one.js', 2, 10, 'baz', map, assert);
170
    util.assertMapping(1, 32, '/the/root/one.js', 2, 14, 'bar', map, assert);
171

172
    util.assertMapping(2, 1, '/the/root/two.js', 1, 1, null, map, assert);
173
    util.assertMapping(2, 5, '/the/root/two.js', 1, 5, null, map, assert);
174
    util.assertMapping(2, 9, '/the/root/two.js', 1, 11, null, map, assert);
175
    util.assertMapping(2, 18, '/the/root/two.js', 1, 21, 'n', map, assert);
176
    util.assertMapping(2, 21, '/the/root/two.js', 2, 3, null, map, assert);
177
    util.assertMapping(2, 28, '/the/root/two.js', 2, 10, 'n', map, assert);
178
  };
179

180
  exports['test mapping tokens fuzzy'] = function (assert, util) {
181
    var map = new SourceMapConsumer(util.testMap);
182

183
    // Finding original positions
184
    util.assertMapping(1, 16, '/the/root/one.js', 1, 21, 'bar', map, assert, true);
185
    util.assertMapping(1, 26, '/the/root/one.js', 2, 10, 'baz', map, assert, true);
186
    util.assertMapping(2, 6, '/the/root/two.js', 1, 11, null, map, assert, true);
187

188
    // Finding generated positions
189
    util.assertMapping(1, 18, '/the/root/one.js', 1, 20, 'bar', map, assert, null, true);
190
    util.assertMapping(1, 28, '/the/root/one.js', 2, 7, 'baz', map, assert, null, true);
191
    util.assertMapping(2, 9, '/the/root/two.js', 1, 6, null, map, assert, null, true);
192
  };
193

194
  exports['test mapping tokens fuzzy in indexed source map'] = function (assert, util) {
195
    var map = new SourceMapConsumer(util.indexedTestMap);
196

197
    // Finding original positions
198
    util.assertMapping(1, 16, '/the/root/one.js', 1, 21, 'bar', map, assert, true);
199
    util.assertMapping(1, 28, '/the/root/one.js', 2, 10, 'baz', map, assert, true);
200
    util.assertMapping(2, 6, '/the/root/two.js', 1, 11, null, map, assert, true);
201

202
    // Finding generated positions
203
    util.assertMapping(1, 18, '/the/root/one.js', 1, 20, 'bar', map, assert, null, true);
204
    util.assertMapping(1, 28, '/the/root/one.js', 2, 7, 'baz', map, assert, null, true);
205
    util.assertMapping(2, 9, '/the/root/two.js', 1, 6, null, map, assert, null, true);
206
  };
207

208
  exports['test mappings and end of lines'] = function (assert, util) {
209
    var smg = new SourceMapGenerator({
210
      file: 'foo.js'
211
    });
212
    smg.addMapping({
213
      original: { line: 1, column: 1 },
214
      generated: { line: 1, column: 1 },
215
      source: 'bar.js'
216
    });
217
    smg.addMapping({
218
      original: { line: 2, column: 2 },
219
      generated: { line: 2, column: 2 },
220
      source: 'bar.js'
221
    });
222

223
    var map = SourceMapConsumer.fromSourceMap(smg);
224

225
    // When finding original positions, mappings end at the end of the line.
226
    util.assertMapping(2, 3, null, null, null, null, map, assert, true)
227

228
    // When finding generated positions, mappings do not end at the end of the line.
229
    util.assertMapping(2, 2, 'bar.js', 1, 2, null, map, assert, null, true);
230
  };
231

232
  exports['test creating source map consumers with )]}\' prefix'] = function (assert, util) {
233
    assert.doesNotThrow(function () {
234
      var map = new SourceMapConsumer(")]}'" + JSON.stringify(util.testMap));
235
    });
236
  };
237

238
  exports['test eachMapping'] = function (assert, util) {
239
    var map;
240

241
    map = new SourceMapConsumer(util.testMap);
242
    var previousLine = -Infinity;
243
    var previousColumn = -Infinity;
244
    map.eachMapping(function (mapping) {
245
      assert.ok(mapping.generatedLine >= previousLine);
246

247
      assert.ok(mapping.source === '/the/root/one.js' || mapping.source === '/the/root/two.js');
248

249
      if (mapping.generatedLine === previousLine) {
250
        assert.ok(mapping.generatedColumn >= previousColumn);
251
        previousColumn = mapping.generatedColumn;
252
      }
253
      else {
254
        previousLine = mapping.generatedLine;
255
        previousColumn = -Infinity;
256
      }
257
    });
258

259
    map = new SourceMapConsumer(util.testMapNoSourceRoot);
260
    map.eachMapping(function (mapping) {
261
      assert.ok(mapping.source === 'one.js' || mapping.source === 'two.js');
262
    });
263

264
    map = new SourceMapConsumer(util.testMapEmptySourceRoot);
265
    map.eachMapping(function (mapping) {
266
      assert.ok(mapping.source === 'one.js' || mapping.source === 'two.js');
267
    });
268
  };
269

270
  exports['test eachMapping for indexed source maps'] = function(assert, util) {
271
    var map = new SourceMapConsumer(util.indexedTestMap);
272
    var previousLine = -Infinity;
273
    var previousColumn = -Infinity;
274
    map.eachMapping(function (mapping) {
275
      assert.ok(mapping.generatedLine >= previousLine);
276

277
      if (mapping.source) {
278
        assert.equal(mapping.source.indexOf(util.testMap.sourceRoot), 0);
279
      }
280

281
      if (mapping.generatedLine === previousLine) {
282
        assert.ok(mapping.generatedColumn >= previousColumn);
283
        previousColumn = mapping.generatedColumn;
284
      }
285
      else {
286
        previousLine = mapping.generatedLine;
287
        previousColumn = -Infinity;
288
      }
289
    });
290
  };
291

292

293
  exports['test iterating over mappings in a different order'] = function (assert, util) {
294
    var map = new SourceMapConsumer(util.testMap);
295
    var previousLine = -Infinity;
296
    var previousColumn = -Infinity;
297
    var previousSource = "";
298
    map.eachMapping(function (mapping) {
299
      assert.ok(mapping.source >= previousSource);
300

301
      if (mapping.source === previousSource) {
302
        assert.ok(mapping.originalLine >= previousLine);
303

304
        if (mapping.originalLine === previousLine) {
305
          assert.ok(mapping.originalColumn >= previousColumn);
306
          previousColumn = mapping.originalColumn;
307
        }
308
        else {
309
          previousLine = mapping.originalLine;
310
          previousColumn = -Infinity;
311
        }
312
      }
313
      else {
314
        previousSource = mapping.source;
315
        previousLine = -Infinity;
316
        previousColumn = -Infinity;
317
      }
318
    }, null, SourceMapConsumer.ORIGINAL_ORDER);
319
  };
320

321
  exports['test iterating over mappings in a different order in indexed source maps'] = function (assert, util) {
322
    var map = new SourceMapConsumer(util.indexedTestMap);
323
    var previousLine = -Infinity;
324
    var previousColumn = -Infinity;
325
    var previousSource = "";
326
    map.eachMapping(function (mapping) {
327
      assert.ok(mapping.source >= previousSource);
328

329
      if (mapping.source === previousSource) {
330
        assert.ok(mapping.originalLine >= previousLine);
331

332
        if (mapping.originalLine === previousLine) {
333
          assert.ok(mapping.originalColumn >= previousColumn);
334
          previousColumn = mapping.originalColumn;
335
        }
336
        else {
337
          previousLine = mapping.originalLine;
338
          previousColumn = -Infinity;
339
        }
340
      }
341
      else {
342
        previousSource = mapping.source;
343
        previousLine = -Infinity;
344
        previousColumn = -Infinity;
345
      }
346
    }, null, SourceMapConsumer.ORIGINAL_ORDER);
347
  };
348

349
  exports['test that we can set the context for `this` in eachMapping'] = function (assert, util) {
350
    var map = new SourceMapConsumer(util.testMap);
351
    var context = {};
352
    map.eachMapping(function () {
353
      assert.equal(this, context);
354
    }, context);
355
  };
356

357
  exports['test that we can set the context for `this` in eachMapping in indexed source maps'] = function (assert, util) {
358
    var map = new SourceMapConsumer(util.indexedTestMap);
359
    var context = {};
360
    map.eachMapping(function () {
361
      assert.equal(this, context);
362
    }, context);
363
  };
364

365
  exports['test that the `sourcesContent` field has the original sources'] = function (assert, util) {
366
    var map = new SourceMapConsumer(util.testMapWithSourcesContent);
367
    var sourcesContent = map.sourcesContent;
368

369
    assert.equal(sourcesContent[0], ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
370
    assert.equal(sourcesContent[1], ' TWO.inc = function (n) {\n   return n + 1;\n };');
371
    assert.equal(sourcesContent.length, 2);
372
  };
373

374
  exports['test that we can get the original sources for the sources'] = function (assert, util) {
375
    var map = new SourceMapConsumer(util.testMapWithSourcesContent);
376
    var sources = map.sources;
377

378
    assert.equal(map.sourceContentFor(sources[0]), ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
379
    assert.equal(map.sourceContentFor(sources[1]), ' TWO.inc = function (n) {\n   return n + 1;\n };');
380
    assert.equal(map.sourceContentFor("one.js"), ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
381
    assert.equal(map.sourceContentFor("two.js"), ' TWO.inc = function (n) {\n   return n + 1;\n };');
382
    assert.throws(function () {
383
      map.sourceContentFor("");
384
    }, Error);
385
    assert.throws(function () {
386
      map.sourceContentFor("/the/root/three.js");
387
    }, Error);
388
    assert.throws(function () {
389
      map.sourceContentFor("three.js");
390
    }, Error);
391
  };
392

393
  exports['test that we can get the original source content with relative source paths'] = function (assert, util) {
394
    var map = new SourceMapConsumer(util.testMapRelativeSources);
395
    var sources = map.sources;
396

397
    assert.equal(map.sourceContentFor(sources[0]), ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
398
    assert.equal(map.sourceContentFor(sources[1]), ' TWO.inc = function (n) {\n   return n + 1;\n };');
399
    assert.equal(map.sourceContentFor("one.js"), ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
400
    assert.equal(map.sourceContentFor("two.js"), ' TWO.inc = function (n) {\n   return n + 1;\n };');
401
    assert.throws(function () {
402
      map.sourceContentFor("");
403
    }, Error);
404
    assert.throws(function () {
405
      map.sourceContentFor("/the/root/three.js");
406
    }, Error);
407
    assert.throws(function () {
408
      map.sourceContentFor("three.js");
409
    }, Error);
410
  };
411

412
  exports['test that we can get the original source content for the sources on an indexed source map'] = function (assert, util) {
413
    var map = new SourceMapConsumer(util.indexedTestMap);
414
    var sources = map.sources;
415

416
    assert.equal(map.sourceContentFor(sources[0]), ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
417
    assert.equal(map.sourceContentFor(sources[1]), ' TWO.inc = function (n) {\n   return n + 1;\n };');
418
    assert.equal(map.sourceContentFor("one.js"), ' ONE.foo = function (bar) {\n   return baz(bar);\n };');
419
    assert.equal(map.sourceContentFor("two.js"), ' TWO.inc = function (n) {\n   return n + 1;\n };');
420
    assert.throws(function () {
421
      map.sourceContentFor("");
422
    }, Error);
423
    assert.throws(function () {
424
      map.sourceContentFor("/the/root/three.js");
425
    }, Error);
426
    assert.throws(function () {
427
      map.sourceContentFor("three.js");
428
    }, Error);
429
  };
430

431

432
  exports['test sourceRoot + generatedPositionFor'] = function (assert, util) {
433
    var map = new SourceMapGenerator({
434
      sourceRoot: 'foo/bar',
435
      file: 'baz.js'
436
    });
437
    map.addMapping({
438
      original: { line: 1, column: 1 },
439
      generated: { line: 2, column: 2 },
440
      source: 'bang.coffee'
441
    });
442
    map.addMapping({
443
      original: { line: 5, column: 5 },
444
      generated: { line: 6, column: 6 },
445
      source: 'bang.coffee'
446
    });
447
    map = new SourceMapConsumer(map.toString());
448

449
    // Should handle without sourceRoot.
450
    var pos = map.generatedPositionFor({
451
      line: 1,
452
      column: 1,
453
      source: 'bang.coffee'
454
    });
455

456
    assert.equal(pos.line, 2);
457
    assert.equal(pos.column, 2);
458

459
    // Should handle with sourceRoot.
460
    var pos = map.generatedPositionFor({
461
      line: 1,
462
      column: 1,
463
      source: 'foo/bar/bang.coffee'
464
    });
465

466
    assert.equal(pos.line, 2);
467
    assert.equal(pos.column, 2);
468
  };
469

470
  exports['test allGeneratedPositionsFor'] = function (assert, util) {
471
    var map = new SourceMapGenerator({
472
      file: 'generated.js'
473
    });
474
    map.addMapping({
475
      original: { line: 1, column: 1 },
476
      generated: { line: 2, column: 2 },
477
      source: 'foo.coffee'
478
    });
479
    map.addMapping({
480
      original: { line: 1, column: 1 },
481
      generated: { line: 2, column: 2 },
482
      source: 'bar.coffee'
483
    });
484
    map.addMapping({
485
      original: { line: 2, column: 1 },
486
      generated: { line: 3, column: 2 },
487
      source: 'bar.coffee'
488
    });
489
    map.addMapping({
490
      original: { line: 2, column: 2 },
491
      generated: { line: 3, column: 3 },
492
      source: 'bar.coffee'
493
    });
494
    map.addMapping({
495
      original: { line: 3, column: 1 },
496
      generated: { line: 4, column: 2 },
497
      source: 'bar.coffee'
498
    });
499
    map = new SourceMapConsumer(map.toString());
500

501
    var mappings = map.allGeneratedPositionsFor({
502
      line: 2,
503
      source: 'bar.coffee'
504
    });
505

506
    assert.equal(mappings.length, 2);
507
    assert.equal(mappings[0].line, 3);
508
    assert.equal(mappings[0].column, 2);
509
    assert.equal(mappings[1].line, 3);
510
    assert.equal(mappings[1].column, 3);
511
  };
512

513
  exports['test allGeneratedPositionsFor for line with no mappings'] = function (assert, util) {
514
    var map = new SourceMapGenerator({
515
      file: 'generated.js'
516
    });
517
    map.addMapping({
518
      original: { line: 1, column: 1 },
519
      generated: { line: 2, column: 2 },
520
      source: 'foo.coffee'
521
    });
522
    map.addMapping({
523
      original: { line: 1, column: 1 },
524
      generated: { line: 2, column: 2 },
525
      source: 'bar.coffee'
526
    });
527
    map.addMapping({
528
      original: { line: 3, column: 1 },
529
      generated: { line: 4, column: 2 },
530
      source: 'bar.coffee'
531
    });
532
    map = new SourceMapConsumer(map.toString());
533

534
    var mappings = map.allGeneratedPositionsFor({
535
      line: 2,
536
      source: 'bar.coffee'
537
    });
538

539
    assert.equal(mappings.length, 0);
540
  };
541

542
  exports['test allGeneratedPositionsFor source map with no mappings'] = function (assert, util) {
543
    var map = new SourceMapGenerator({
544
      file: 'generated.js'
545
    });
546
    map = new SourceMapConsumer(map.toString());
547

548
    var mappings = map.allGeneratedPositionsFor({
549
      line: 2,
550
      source: 'bar.coffee'
551
    });
552

553
    assert.equal(mappings.length, 0);
554
  };
555

556
  exports['test computeColumnSpans'] = function (assert, util) {
557
    var map = new SourceMapGenerator({
558
      file: 'generated.js'
559
    });
560
    map.addMapping({
561
      original: { line: 1, column: 1 },
562
      generated: { line: 1, column: 1 },
563
      source: 'foo.coffee'
564
    });
565
    map.addMapping({
566
      original: { line: 2, column: 1 },
567
      generated: { line: 2, column: 1 },
568
      source: 'foo.coffee'
569
    });
570
    map.addMapping({
571
      original: { line: 2, column: 2 },
572
      generated: { line: 2, column: 10 },
573
      source: 'foo.coffee'
574
    });
575
    map.addMapping({
576
      original: { line: 2, column: 3 },
577
      generated: { line: 2, column: 20 },
578
      source: 'foo.coffee'
579
    });
580
    map.addMapping({
581
      original: { line: 3, column: 1 },
582
      generated: { line: 3, column: 1 },
583
      source: 'foo.coffee'
584
    });
585
    map.addMapping({
586
      original: { line: 3, column: 2 },
587
      generated: { line: 3, column: 2 },
588
      source: 'foo.coffee'
589
    });
590
    map = new SourceMapConsumer(map.toString());
591

592
    map.computeColumnSpans();
593

594
    var mappings = map.allGeneratedPositionsFor({
595
      line: 1,
596
      source: 'foo.coffee'
597
    });
598

599
    assert.equal(mappings.length, 1);
600
    // assert.equal(mappings[0].lastColumn, Infinity);
601

602
    var mappings = map.allGeneratedPositionsFor({
603
      line: 2,
604
      source: 'foo.coffee'
605
    });
606

607
    assert.equal(mappings.length, 3);
608
    assert.equal(mappings[0].lastColumn, 9);
609
    assert.equal(mappings[1].lastColumn, 19);
610
    assert.equal(mappings[2].lastColumn, Infinity);
611

612
    var mappings = map.allGeneratedPositionsFor({
613
      line: 3,
614
      source: 'foo.coffee'
615
    });
616

617
    assert.equal(mappings.length, 2);
618
    assert.equal(mappings[0].lastColumn, 1);
619
    assert.equal(mappings[1].lastColumn, Infinity);
620
  };
621

622
  exports['test sourceRoot + originalPositionFor'] = function (assert, util) {
623
    var map = new SourceMapGenerator({
624
      sourceRoot: 'foo/bar',
625
      file: 'baz.js'
626
    });
627
    map.addMapping({
628
      original: { line: 1, column: 1 },
629
      generated: { line: 2, column: 2 },
630
      source: 'bang.coffee'
631
    });
632
    map = new SourceMapConsumer(map.toString());
633

634
    var pos = map.originalPositionFor({
635
      line: 2,
636
      column: 2,
637
    });
638

639
    // Should always have the prepended source root
640
    assert.equal(pos.source, 'foo/bar/bang.coffee');
641
    assert.equal(pos.line, 1);
642
    assert.equal(pos.column, 1);
643
  };
644

645
  exports['test github issue #56'] = function (assert, util) {
646
    var map = new SourceMapGenerator({
647
      sourceRoot: 'http://',
648
      file: 'www.example.com/foo.js'
649
    });
650
    map.addMapping({
651
      original: { line: 1, column: 1 },
652
      generated: { line: 2, column: 2 },
653
      source: 'www.example.com/original.js'
654
    });
655
    map = new SourceMapConsumer(map.toString());
656

657
    var sources = map.sources;
658
    assert.equal(sources.length, 1);
659
    assert.equal(sources[0], 'http://www.example.com/original.js');
660
  };
661

662
  exports['test github issue #43'] = function (assert, util) {
663
    var map = new SourceMapGenerator({
664
      sourceRoot: 'http://example.com',
665
      file: 'foo.js'
666
    });
667
    map.addMapping({
668
      original: { line: 1, column: 1 },
669
      generated: { line: 2, column: 2 },
670
      source: 'http://cdn.example.com/original.js'
671
    });
672
    map = new SourceMapConsumer(map.toString());
673

674
    var sources = map.sources;
675
    assert.equal(sources.length, 1,
676
                 'Should only be one source.');
677
    assert.equal(sources[0], 'http://cdn.example.com/original.js',
678
                 'Should not be joined with the sourceRoot.');
679
  };
680

681
  exports['test absolute path, but same host sources'] = function (assert, util) {
682
    var map = new SourceMapGenerator({
683
      sourceRoot: 'http://example.com/foo/bar',
684
      file: 'foo.js'
685
    });
686
    map.addMapping({
687
      original: { line: 1, column: 1 },
688
      generated: { line: 2, column: 2 },
689
      source: '/original.js'
690
    });
691
    map = new SourceMapConsumer(map.toString());
692

693
    var sources = map.sources;
694
    assert.equal(sources.length, 1,
695
                 'Should only be one source.');
696
    assert.equal(sources[0], 'http://example.com/original.js',
697
                 'Source should be relative the host of the source root.');
698
  };
699

700
  exports['test indexed source map errors when sections are out of order by line'] = function(assert, util) {
701
    // Make a deep copy of the indexedTestMap
702
    var misorderedIndexedTestMap = JSON.parse(JSON.stringify(util.indexedTestMap));
703

704
    misorderedIndexedTestMap.sections[0].offset = {
705
      line: 2,
706
      column: 0
707
    };
708

709
    assert.throws(function() {
710
      new SourceMapConsumer(misorderedIndexedTestMap);
711
    }, Error);
712
  };
713

714
  exports['test github issue #64'] = function (assert, util) {
715
    var map = new SourceMapConsumer({
716
      "version": 3,
717
      "file": "foo.js",
718
      "sourceRoot": "http://example.com/",
719
      "sources": ["/a"],
720
      "names": [],
721
      "mappings": "AACA",
722
      "sourcesContent": ["foo"]
723
    });
724

725
    assert.equal(map.sourceContentFor("a"), "foo");
726
    assert.equal(map.sourceContentFor("/a"), "foo");
727
  };
728

729
  exports['test bug 885597'] = function (assert, util) {
730
    var map = new SourceMapConsumer({
731
      "version": 3,
732
      "file": "foo.js",
733
      "sourceRoot": "file:///Users/AlGore/Invented/The/Internet/",
734
      "sources": ["/a"],
735
      "names": [],
736
      "mappings": "AACA",
737
      "sourcesContent": ["foo"]
738
    });
739

740
    var s = map.sources[0];
741
    assert.equal(map.sourceContentFor(s), "foo");
742
  };
743

744
  exports['test github issue #72, duplicate sources'] = function (assert, util) {
745
    var map = new SourceMapConsumer({
746
      "version": 3,
747
      "file": "foo.js",
748
      "sources": ["source1.js", "source1.js", "source3.js"],
749
      "names": [],
750
      "mappings": ";EAAC;;IAEE;;MEEE",
751
      "sourceRoot": "http://example.com"
752
    });
753

754
    var pos = map.originalPositionFor({
755
      line: 2,
756
      column: 2
757
    });
758
    assert.equal(pos.source, 'http://example.com/source1.js');
759
    assert.equal(pos.line, 1);
760
    assert.equal(pos.column, 1);
761

762
    var pos = map.originalPositionFor({
763
      line: 4,
764
      column: 4
765
    });
766
    assert.equal(pos.source, 'http://example.com/source1.js');
767
    assert.equal(pos.line, 3);
768
    assert.equal(pos.column, 3);
769

770
    var pos = map.originalPositionFor({
771
      line: 6,
772
      column: 6
773
    });
774
    assert.equal(pos.source, 'http://example.com/source3.js');
775
    assert.equal(pos.line, 5);
776
    assert.equal(pos.column, 5);
777
  };
778

779
  exports['test github issue #72, duplicate names'] = function (assert, util) {
780
    var map = new SourceMapConsumer({
781
      "version": 3,
782
      "file": "foo.js",
783
      "sources": ["source.js"],
784
      "names": ["name1", "name1", "name3"],
785
      "mappings": ";EAACA;;IAEEA;;MAEEE",
786
      "sourceRoot": "http://example.com"
787
    });
788

789
    var pos = map.originalPositionFor({
790
      line: 2,
791
      column: 2
792
    });
793
    assert.equal(pos.name, 'name1');
794
    assert.equal(pos.line, 1);
795
    assert.equal(pos.column, 1);
796

797
    var pos = map.originalPositionFor({
798
      line: 4,
799
      column: 4
800
    });
801
    assert.equal(pos.name, 'name1');
802
    assert.equal(pos.line, 3);
803
    assert.equal(pos.column, 3);
804

805
    var pos = map.originalPositionFor({
806
      line: 6,
807
      column: 6
808
    });
809
    assert.equal(pos.name, 'name3');
810
    assert.equal(pos.line, 5);
811
    assert.equal(pos.column, 5);
812
  };
813

814
  exports['test SourceMapConsumer.fromSourceMap'] = function (assert, util) {
815
    var smg = new SourceMapGenerator({
816
      sourceRoot: 'http://example.com/',
817
      file: 'foo.js'
818
    });
819
    smg.addMapping({
820
      original: { line: 1, column: 1 },
821
      generated: { line: 2, column: 2 },
822
      source: 'bar.js'
823
    });
824
    smg.addMapping({
825
      original: { line: 2, column: 2 },
826
      generated: { line: 4, column: 4 },
827
      source: 'baz.js',
828
      name: 'dirtMcGirt'
829
    });
830
    smg.setSourceContent('baz.js', 'baz.js content');
831

832
    var smc = SourceMapConsumer.fromSourceMap(smg);
833
    assert.equal(smc.file, 'foo.js');
834
    assert.equal(smc.sourceRoot, 'http://example.com/');
835
    assert.equal(smc.sources.length, 2);
836
    assert.equal(smc.sources[0], 'http://example.com/bar.js');
837
    assert.equal(smc.sources[1], 'http://example.com/baz.js');
838
    assert.equal(smc.sourceContentFor('baz.js'), 'baz.js content');
839

840
    var pos = smc.originalPositionFor({
841
      line: 2,
842
      column: 2
843
    });
844
    assert.equal(pos.line, 1);
845
    assert.equal(pos.column, 1);
846
    assert.equal(pos.source, 'http://example.com/bar.js');
847
    assert.equal(pos.name, null);
848

849
    pos = smc.generatedPositionFor({
850
      line: 1,
851
      column: 1,
852
      source: 'http://example.com/bar.js'
853
    });
854
    assert.equal(pos.line, 2);
855
    assert.equal(pos.column, 2);
856

857
    pos = smc.originalPositionFor({
858
      line: 4,
859
      column: 4
860
    });
861
    assert.equal(pos.line, 2);
862
    assert.equal(pos.column, 2);
863
    assert.equal(pos.source, 'http://example.com/baz.js');
864
    assert.equal(pos.name, 'dirtMcGirt');
865

866
    pos = smc.generatedPositionFor({
867
      line: 2,
868
      column: 2,
869
      source: 'http://example.com/baz.js'
870
    });
871
    assert.equal(pos.line, 4);
872
    assert.equal(pos.column, 4);
873
  };
874
});
875

876
Product

Resources

Company
