From 094c4b575002b60d09c010259f71e19e949d3a9c Mon Sep 17 00:00:00 2001 From: Morten Houston Ludvigsen Date: Mon, 18 Aug 2014 15:33:03 +0200 Subject: [PATCH] Added definitions for source-map --- CONTRIBUTORS.md | 1 + source-map/source-map-tests.ts | 165 +++++++++++++++++++++++++++++++++ source-map/source-map.d.ts | 90 ++++++++++++++++++ 3 files changed, 256 insertions(+) create mode 100644 source-map/source-map-tests.ts create mode 100644 source-map/source-map.d.ts diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index b8aecd835..cd95442e8 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -325,6 +325,7 @@ All definitions files include a header with the author and editors, so at some p * [SockJS](https://github.com/sockjs/sockjs-client) (by [Emil Ivanov](https://github.com/vladev)) * [sockjs-node](https://github.com/sockjs/sockjs-node) (by [Phil McCloghry-Laing](https://github.com/pmccloghrylaing)) * [SoundJS](http://www.createjs.com/#!/SoundJS) (by [Pedro Ferreira](https://bitbucket.org/drk4)) +* [source-map](https://github.com/mozilla/source-map) (by [Morten Houston Ludvigsen](https://github.com/MortenHoustonLudvigsen)) * [Spin](http://fgnass.github.com/spin.js/) (by [Boris Yankov](https://github.com/borisyankov)) * [sqlite3](https://github.com/mapbox/node-sqlite3) (by [Nick Malaguti](https://github.com/nmalaguti)) * [status-bar](https://github.com/atom/status-bar) (by [vvakame](https://github.com/vvakame)) diff --git a/source-map/source-map-tests.ts b/source-map/source-map-tests.ts new file mode 100644 index 000000000..f7ad78e85 --- /dev/null +++ b/source-map/source-map-tests.ts @@ -0,0 +1,165 @@ +import SourceMap = require('source-map'); + +function testSourceMapConsumer() { + function testConstructor() { + var scm: SourceMap.SourceMapConsumer; + + // create with full RawSourceMap + scm = new SourceMap.SourceMapConsumer({ + version: 'foo', + sources: ['foo', 'bar'], + names: ['foo', 'bar'], + sourcesContent: 'foo', + mappings: 'foo' + }); + + // create with partial RawSourceMap + scm = new SourceMap.SourceMapConsumer({ + version: 'foo', + sources: ['foo', 'bar'], + names: ['foo', 'bar'], + mappings: 'foo' + }); + } + + function testOriginalPositionFor(scm: SourceMap.SourceMapConsumer) { + var origPos: SourceMap.MappedPosition; + origPos = scm.originalPositionFor({ line: 42, column: 42 }); + } + + function testGeneratedPositionFor(scm: SourceMap.SourceMapConsumer) { + var genPos: SourceMap.Position; + genPos = scm.generatedPositionFor({ line: 42, column: 42, source: 'foo' }); + genPos = scm.generatedPositionFor({ line: 42, column: 42, source: 'foo', name: 'bar' }); + } + + function testSourceContentFor(scm: SourceMap.SourceMapConsumer) { + var content: string; + content = scm.sourceContentFor('foo'); + } + + function testEachMapping(scm: SourceMap.SourceMapConsumer) { + var x: SourceMap.MappingItem; + var context: {}; + + scm.eachMapping(mapping => { x = mapping; }); + scm.eachMapping(mapping => { x = mapping; }, context); + scm.eachMapping(mapping => { x = mapping; }, context, SourceMap.SourceMapConsumer.GENERATED_ORDER); + scm.eachMapping(mapping => { x = mapping; }, context, SourceMap.SourceMapConsumer.ORIGINAL_ORDER); + } +} + +function testSourceMapGenerator() { + function testConstructor() { + var generator: SourceMap.SourceMapGenerator; + + generator = new SourceMap.SourceMapGenerator(); + generator = new SourceMap.SourceMapGenerator({ + file: 'foo' + }); + generator = new SourceMap.SourceMapGenerator({ + sourceRoot: 'foo' + }); + generator = new SourceMap.SourceMapGenerator({ + file: 'foo', + sourceRoot: 'bar' + }); + } + + function testFromSourceMap(generator: SourceMap.SourceMapGenerator, scm: SourceMap.SourceMapConsumer) { + generator = SourceMap.SourceMapGenerator.fromSourceMap(scm); + } + + function testAddMapping(generator: SourceMap.SourceMapGenerator) { + generator.addMapping({ + generated: { line: 42, column: 42 }, + original: { line: 42, column: 42 }, + source: 'foo', + name: 'foo' + }); + + generator.addMapping({ + generated: { line: 42, column: 42 }, + original: { line: 42, column: 42 }, + source: 'foo' + }); + } + + function testSetSourceContent(generator: SourceMap.SourceMapGenerator) { + generator.setSourceContent('foo', 'bar'); + } + + function testApplySourceMap(generator: SourceMap.SourceMapGenerator, scm: SourceMap.SourceMapConsumer) { + generator.applySourceMap(scm); + generator.applySourceMap(scm, 'foo'); + generator.applySourceMap(scm, 'foo', 'bar'); + } + + function testToString(generator: SourceMap.SourceMapGenerator) { + var str: string; + str = generator.toString(); + } +} + +function testSourceNode() { + function testConstructor() { + var node: SourceMap.SourceNode; + + node = new SourceMap.SourceNode(); + node = new SourceMap.SourceNode(42, 42, 'foo'); + node = new SourceMap.SourceNode(42, 42, 'foo', 'bar'); + node = new SourceMap.SourceNode(42, 42, 'foo', 'bar', 'slam'); + } + + function testFromStringWithSourceMap(scm: SourceMap.SourceMapConsumer) { + var node: SourceMap.SourceNode; + + node = SourceMap.SourceNode.fromStringWithSourceMap('foo', scm); + node = SourceMap.SourceNode.fromStringWithSourceMap('foo', scm, 'bar'); + } + + function testAdd(node: SourceMap.SourceNode) { + node.add('foo'); + } + + function testPrepend(node: SourceMap.SourceNode) { + node.prepend('foo'); + } + + function testSetSourceContent(node: SourceMap.SourceNode) { + node.setSourceContent('foo', 'bar'); + } + + function testWalk(node: SourceMap.SourceNode) { + var chunk: string; + var mapping: SourceMap.MappedPosition; + + node.walk((c, m) => { chunk = c; mapping = m; }); + } + + function testWalkSourceContents(node: SourceMap.SourceNode) { + var file: string; + var content: string; + + node.walkSourceContents((f, c) => { file = f; content = c; }); + } + + function testJoin(node: SourceMap.SourceNode) { + node = node.join('foo'); + } + + function testReplaceRight(node: SourceMap.SourceNode) { + node = node.replaceRight('foo', 'bar'); + } + + function testToString(node: SourceMap.SourceNode) { + var str: string; + str = node.toString(); + } + + function testToStringWithSourceMap(node: SourceMap.SourceNode, sos: SourceMap.StartOfSourceMap) { + var result: SourceMap.CodeWithSourceMap; + result = node.toStringWithSourceMap(); + result = node.toStringWithSourceMap(sos); + } +} \ No newline at end of file diff --git a/source-map/source-map.d.ts b/source-map/source-map.d.ts new file mode 100644 index 000000000..a1d8e208b --- /dev/null +++ b/source-map/source-map.d.ts @@ -0,0 +1,90 @@ +// Type definitions for source-map v0.1.38 +// Project: https://github.com/mozilla/source-map +// Definitions by: Morten Houston Ludvigsen +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module SourceMap { + interface StartOfSourceMap { + file?: string; + sourceRoot?: string; + } + + interface RawSourceMap extends StartOfSourceMap { + version: string; + sources: Array; + names: Array; + sourcesContent?: string; + mappings: string; + } + + interface Position { + line: number; + column: number; + } + + interface MappedPosition extends Position { + source: string; + name?: string; + } + + interface MappingItem { + source: string; + generatedLine: number; + generatedColumn: number; + originalLine: number; + originalColumn: number; + name: string; + } + + interface Mapping { + generated: Position; + original: Position; + source: string; + name?: string; + } + + interface CodeWithSourceMap { + code: string; + map: SourceMapGenerator; + } + + class SourceMapConsumer { + public static GENERATED_ORDER: number; + public static ORIGINAL_ORDER: number; + + constructor(rawSourceMap: RawSourceMap); + public originalPositionFor(generatedPosition: Position): MappedPosition; + public generatedPositionFor(originalPosition: MappedPosition): Position; + public sourceContentFor(source: string): string; + public eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void; + } + + class SourceMapGenerator { + constructor(startOfSourceMap?: StartOfSourceMap); + public static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator; + public addMapping(mapping: Mapping): void; + public setSourceContent(sourceFile: string, sourceContent: string): void; + public applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void; + public toString(): string; + } + + class SourceNode { + constructor(); + constructor(line: number, column: number, source: string); + constructor(line: number, column: number, source: string, chunk?: string, name?: string); + public static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode; + public add(chunk: string): void; + public prepend(chunk: string): void; + public setSourceContent(sourceFile: string, sourceContent: string): void; + public walk(fn: (chunk: string, mapping: MappedPosition) => void): void; + public walkSourceContents(fn: (file: string, content: string) => void): void; + public join(sep: string): SourceNode; + public replaceRight(pattern: string, replacement: string): SourceNode; + public toString(): string; + public toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap; + } +} + +declare module 'source-map' { + export = SourceMap; +}