From 2d76fd638294c140626cc3e3aebc8b89fc969761 Mon Sep 17 00:00:00 2001 From: tkqubo Date: Wed, 13 Jan 2016 17:49:33 +0900 Subject: [PATCH 1/8] fix: more appropriate interface name for OSM models --- osmtogeojson/osmtogeojson-tests.ts | 2 +- osmtogeojson/osmtogeojson.d.ts | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/osmtogeojson/osmtogeojson-tests.ts b/osmtogeojson/osmtogeojson-tests.ts index a4debe4c1..f7d52c075 100644 --- a/osmtogeojson/osmtogeojson-tests.ts +++ b/osmtogeojson/osmtogeojson-tests.ts @@ -33,7 +33,7 @@ osmtogeojson(xml, { uninterestingTags: {foo:true} }); -let json: OsmJSON.Root = { +let json: OsmJSON.OsmJSONObject = { elements: [ { type: "node", diff --git a/osmtogeojson/osmtogeojson.d.ts b/osmtogeojson/osmtogeojson.d.ts index 0edee3509..ad29c1b73 100644 --- a/osmtogeojson/osmtogeojson.d.ts +++ b/osmtogeojson/osmtogeojson.d.ts @@ -5,8 +5,8 @@ declare module "osmtogeojson" { export interface OsmToGeoJSON { - (data: Document|OsmJSON.Root, options?: Options): GeoJSON.GeoJSONObject; - toGeojson(data: Document|OsmJSON.Root, options?: Options): GeoJSON.GeoJSONObject; + (data: Document|OsmJSON.OsmJSONObject, options?: Options): GeoJSON.GeoJSONObject; + toGeojson(data: Document|OsmJSON.OsmJSONObject, options?: Options): GeoJSON.GeoJSONObject; } export interface Options { @@ -54,11 +54,11 @@ declare module "osmtogeojson" { } export namespace OsmJSON { - export interface Root { + export interface OsmJSONObject { elements: (Node|Way|Relationship)[]; } - export interface OsmJSONObject { + export interface Element { type: string; id: number; tags?: { [name: string]: string; } @@ -69,16 +69,16 @@ declare module "osmtogeojson" { uid?: number; } - export interface Node extends OsmJSONObject { + export interface Node extends Element { lat: number; lon: number; } - export interface Way extends OsmJSONObject { + export interface Way extends Element { nodes: number[]; } - export interface Relationship extends OsmJSONObject { + export interface Relationship extends Element { members: Member[]; } From 5aa6dff6990465c7fb41504538ad7aa133ab01d3 Mon Sep 17 00:00:00 2001 From: jwbay Date: Wed, 13 Jan 2016 23:29:30 -0500 Subject: [PATCH 2/8] update typings for should.js from 3.x to 8.x --- should/should-tests.ts | 150 ++++++++++++++++++++++++++++++++--------- should/should.d.ts | 93 ++++++++++++++++++------- 2 files changed, 186 insertions(+), 57 deletions(-) diff --git a/should/should-tests.ts b/should/should-tests.ts index 43b21d0ef..41c814aea 100644 --- a/should/should-tests.ts +++ b/should/should-tests.ts @@ -15,6 +15,20 @@ should.throws(() => {}); should.doesNotThrow(() => {}); should.ifError('value'); +(0).should + .a + .an + .and + .be + .has + .have + .is + .it + .of + .the + .which + .with + .equal(0) class User { name: string; @@ -60,36 +74,48 @@ should.not.exist(null); should.not.exist(''); should.not.exist({}); -true.should.be.ok; -'yay'.should.be.ok; -(1).should.be.ok; +true.should.be.ok(); +'yay'.should.be.ok(); +(1).should.be.ok(); -false.should.not.be.ok; -''.should.not.be.ok; -(0).should.not.be.ok; +false.should.not.be.ok(); +''.should.not.be.ok(); +(0).should.not.be.ok(); -true.should.be.true -'1'.should.not.be.true -false +true.should.be.true(); +true.should.be.True(); +'1'.should.not.be.true(); -false.should.be.false; -(0).should.not.be.false; +false.should.be.false(); +false.should.be.False(); +(0).should.not.be.false(); var args = function (a: string, b: string, c: string) { return arguments; }; -args.should.be.arguments; -['a'].should.not.be.arguments; +args.should.be.arguments(); +args.should.be.Arguments(); +['a'].should.not.be.arguments(); -['a'].should.be.empty; -''.should.be.empty; -({ length: 0 }).should.be.empty; +['a'].should.be.empty(); +''.should.be.empty(); +({ length: 0 }).should.be.empty(); ({ foo: 'bar' }).should.eql({ foo: 'bar' }); [1, 2, 3].should.eql([1, 2, 3]); +[1, 2, 3].should.deepEqual([1, 2, 3]); (4).should.equal(4); 'test'.should.equal('test'); [1, 2, 3].should.not.equal([1, 2, 3]); +'ab'.should.equalOneOf('a', 10, 'ab'); +'ab'.should.equalOneOf(['a', 10, 'ab']); + +({a: 10}).should.be.oneOf('a', 10, 'ab', {a: 10}); +({a: 10}).should.be.oneOf(['a', 10, 'ab', {a: 10}]); + +'1'.should.be.exactly('1'); +'1'.should.not.be.exactly(1); + user.age.should.be.within(5, 50); user.should.be.of.type('object'); @@ -114,7 +140,29 @@ user.should.have.property('age', 15); user.should.not.have.property('rawr'); user.should.not.have.property('age', 0); +({ a: 10 }).should.have.properties('a'); +({ a: 10, b: 20 }).should.have.properties([ 'a' ]); +({ a: 10, b: 20 }).should.have.properties({ b: 20 }); ({ foo: 'bar' }).should.have.ownProperty('foo'); +({ foo: 'bar' }).should.hasOwnProperty('foo'); +({ a: {b: 10}}).should.have.propertyByPath('a', 'b').eql(10); +({ a: 10 }).should.have.propertyWithDescriptor('a', { enumerable: true }); + +NaN.should.be.NaN(); +Infinity.should.be.Infinity(); +new Date().should.be.a.Date(); +({}).should.be.an.Object(); +"".should.be.a.String(); +true.should.be.a.Boolean(); +(4).should.be.a.Number(); +new ReferenceError("error").should.be.an.Error(); +(function() {}).should.be.a.Function(); +User.should.be.a.class(); +User.should.be.a.Class(); +'a'.should.not.be.a.generator(); +[].should.be.iterable(); +[].should.be.an.iterator(); +[].should.be.an.Array(); var res = {}; res.should.have.status(200); @@ -123,30 +171,60 @@ res.should.have.header('content-length'); res.should.have.header('Content-Length', '123'); res.should.have.header('content-length', '123'); -res.should.be.json; +res.should.be.json(); -res.should.be.html; +res.should.be.html(); -[1, 2, 3].should.include(3); -[1, 2, 3].should.include(2); -[1, 2, 3].should.not.include(4); +[1, 2, 3].should.containEql(3); +[1, 2, 3].should.containEql(2); +[1, 2, 3].should.not.containEql(4); -'foo bar baz'.should.include('foo'); -'foo bar baz'.should.include('bar'); -'foo bar baz'.should.include('baz'); -'foo bar baz'.should.not.include('FOO'); +'foo bar baz'.should.containEql('foo'); +'foo bar baz'.should.containEql('bar'); +'foo bar baz'.should.containEql('baz'); +'foo bar baz'.should.not.containEql('FOO') var tobi = { name: 'Tobi', age: 1 }; var jane = { name: 'Jane', age: 5 }; var tj = { name: 'TJ', pet: tobi }; -tj.should.include({ pet: tobi }); -tj.should.include({ pet: tobi, name: 'TJ' }); -tj.should.not.include({ pet: jane }); -tj.should.not.include({ name: 'Someone' }); +tj.should.containEql({ pet: tobi }); +tj.should.containEql({ pet: tobi, name: 'TJ' }); +tj.should.not.containEql({ pet: jane }); +tj.should.not.containEql({ name: 'Someone' }); -[[1], [2], [3]].should.includeEql([3]); -[[1], [2], [3]].should.includeEql([2]); -[[1], [2], [3]].should.not.includeEql([4]); +[[1], [2], [3]].should.containEql([3]); +[[1], [2], [3]].should.containEql([2]); +[[1], [2], [3]].should.not.containEql([4]); + +var spy = function() { }; +spy.should.be.alwaysCalledOn({}); +spy.should.be.alwaysCalledWith(1, 2); +spy.should.be.alwaysCalledWithExactly(1, 2); +spy.should.be.alwaysCalledWithMatch(1, 2); +spy.should.have.alwaysThrew("ReferenceError"); +spy.should.have.callCount(1); +spy.should.be.called(); +spy.should.be.calledOn({}); +spy.should.be.calledOnce(); +spy.should.be.calledTwice(); +spy.should.be.calledThrice(); +spy.should.be.calledWith(1, 2); +spy.should.be.calledWithExactly(1, 2); +spy.should.be.calledWithMatch(1, 2); +spy.should.be.calledWithNew(); +spy.should.be.neverCalledWith(1, 2); +spy.should.be.neverCalledWithMatch(1, 2); +spy.should.have.threw("ReferenceError"); + +(10).should.be.aboveOrEqual(0); +(10).should.be.aboveOrEqual(10); +(10).should.be.greaterThanOrEqual(0); +(10).should.be.greaterThanOrEqual(10); + +(0).should.be.belowOrEqual(10); +(0).should.be.belowOrEqual(0); +(0).should.be.lessThanOrEqual(10); +(0).should.be.lessThanOrEqual(0); (function () { throw new Error('fail'); @@ -170,9 +248,17 @@ tj.should.not.include({ name: 'Someone' }); var obj = { foo: 'bar', baz: 'raz' }; obj.should.have.keys('foo', 'bar'); obj.should.have.keys(['foo', 'bar']); +obj.should.have.key('foo'); + +({ a: 10 }).should.have.enumerable('a'); +({ a: 10 }).should.have.enumerable('a', 10); +({ a: 10, b: 10 }).should.have.enumerables('a', 'b'); (1).should.eql(0, 'some useful description'); +[ 1, 2, 3].should.containDeep([2, 1]); +[ 1, 2, [ 1, 2, 3 ]].should.containDeep([ 1, [ 3, 1 ]]); + [ 1, 2, 3].should.containDeepOrdered([1, 2]); [ 1, 2, [ 1, 2, 3 ]].should.containDeepOrdered([ 1, [ 2, 3 ]]); diff --git a/should/should.d.ts b/should/should.d.ts index 26a42d7ed..d4ab3ef38 100644 --- a/should/should.d.ts +++ b/should/should.d.ts @@ -1,5 +1,5 @@ -// Type definitions for should.js 3.1.2 -// Project: https://github.com/visionmedia/should.js +// Type definitions for should.js v8.1.1 +// Project: https://github.com/shouldjs/should.js // Definitions by: Alex Varju , Maxime LUCE // Definitions: https://github.com/borisyankov/DefinitelyTyped @@ -13,34 +13,49 @@ interface ShouldAssertion { an: ShouldAssertion; and: ShouldAssertion; be: ShouldAssertion; + has: ShouldAssertion; have: ShouldAssertion; + is: ShouldAssertion; + it: ShouldAssertion; with: ShouldAssertion; + which: ShouldAssertion; + the: ShouldAssertion; of: ShouldAssertion; not: ShouldAssertion; // validators - arguments: ShouldAssertion; - empty: ShouldAssertion; - ok: ShouldAssertion; - true: ShouldAssertion; - false: ShouldAssertion; - NaN: ShouldAssertion; - Infinity: ShouldAssertion; - Array: ShouldAssertion; - Object: ShouldAssertion; - String: ShouldAssertion; - Boolean: ShouldAssertion; - Number: ShouldAssertion; - Error: ShouldAssertion; - Function: ShouldAssertion; + arguments(): ShouldAssertion; + empty(): ShouldAssertion; + ok(): ShouldAssertion; + true(): ShouldAssertion; + false(): ShouldAssertion; + NaN(): ShouldAssertion; + Infinity(): ShouldAssertion; + Array(): ShouldAssertion; + Object(): ShouldAssertion; + String(): ShouldAssertion; + Boolean(): ShouldAssertion; + Number(): ShouldAssertion; + Error(): ShouldAssertion; + Function(): ShouldAssertion; + Date(): ShouldAssertion; + Class(): ShouldAssertion; + generator(): ShouldAssertion; + iterable(): ShouldAssertion; + iterator(): ShouldAssertion; eql(expected: any, description?: string): ShouldAssertion; equal(expected: any, description?: string): ShouldAssertion; + equalOneOf(...values: any[]): ShouldAssertion; within(start: number, finish: number, description?: string): ShouldAssertion; approximately(value: number, delta: number, description?: string): ShouldAssertion; type(expected: any, description?: string): ShouldAssertion; instanceof(constructor: Function, description?: string): ShouldAssertion; above(n: number, description?: string): ShouldAssertion; below(n: number, description?: string): ShouldAssertion; + aboveOrEqual(n: number, description?: string): ShouldAssertion; + greaterThanOrEqual(n: number, description?: string): ShouldAssertion; + belowOrEqual(n: number, description?: string): ShouldAssertion; + lessThanOrEqual(n: number, description?: string): ShouldAssertion; match(other: {}, description?: string): ShouldAssertion; match(other: (val: any) => any, description?: string): ShouldAssertion; match(regexp: RegExp, description?: string): ShouldAssertion; @@ -60,32 +75,60 @@ interface ShouldAssertion { properties(name: string): ShouldAssertion; properties(descriptor: any): ShouldAssertion; properties(...properties: string[]): ShouldAssertion; + propertyByPath(...properties: string[]): ShouldAssertion; + propertyWithDescriptor(name: string, descriptor: PropertyDescriptor): ShouldAssertion; + oneOf(...values: any[]): ShouldAssertion; ownProperty(name: string, description?: string): ShouldAssertion; - contain(obj: any): ShouldAssertion; containEql(obj: any): ShouldAssertion; containDeep(obj: any): ShouldAssertion; containDeepOrdered(obj: any): ShouldAssertion; keys(...allKeys: string[]): ShouldAssertion; keys(allKeys: string[]): ShouldAssertion; - header(field: string, val?: string): ShouldAssertion; - status(code: number): ShouldAssertion; - json: ShouldAssertion; - html: ShouldAssertion; + enumerable(property: string, value?: any): ShouldAssertion; + enumerables(...properties: string[]): ShouldAssertion; startWith(expected: string, message?: any): ShouldAssertion; endWith(expected: string, message?: any): ShouldAssertion; throw(message?: any): ShouldAssertion; - // deprecated - include(obj: any, description?: string): ShouldAssertion; - includeEql(obj: any[], description?: string): ShouldAssertion; + //http + header(field: string, val?: string): ShouldAssertion; + status(code: number): ShouldAssertion; + json(): ShouldAssertion; + html(): ShouldAssertion; + + //stubs + alwaysCalledOn(thisTarget: any): ShouldAssertion; + alwaysCalledWith(...arguments: any[]): ShouldAssertion; + alwaysCalledWithExactly(...arguments: any[]): ShouldAssertion; + alwaysCalledWithMatch(...arguments: any[]): ShouldAssertion; + alwaysCalledWithNew(): ShouldAssertion; + alwaysThrew(exception?: any): ShouldAssertion; + callCount(count: number): ShouldAssertion; + called(): ShouldAssertion; + calledOn(thisTarget: any): ShouldAssertion; + calledOnce(): ShouldAssertion; + calledTwice(): ShouldAssertion; + calledThrice(): ShouldAssertion; + calledWith(...arguments: any[]): ShouldAssertion; + calledWithExactly(...arguments: any[]): ShouldAssertion; + calledWithMatch(...arguments: any[]): ShouldAssertion; + calledWithNew(): ShouldAssertion; + neverCalledWith(...arguments: any[]): ShouldAssertion; + neverCalledWithMatch(...arguments: any[]): ShouldAssertion; + threw(exception?: any): ShouldAssertion; // aliases + True(): ShouldAssertion; + False(): ShouldAssertion; + Arguments(): ShouldAssertion; + class(): ShouldAssertion; + deepEqual(expected: any, description?: string): ShouldAssertion; exactly(expected: any, description?: string): ShouldAssertion; instanceOf(constructor: Function, description?: string): ShouldAssertion; throwError(message?: any): ShouldAssertion; lengthOf(n: number, description?: string): ShouldAssertion; key(key: string): ShouldAssertion; - haveOwnProperty(name: string, description?: string): ShouldAssertion; + hasOwnProperty(name: string, description?: string): ShouldAssertion; greaterThan(n: number, description?: string): ShouldAssertion; lessThan(n: number, description?: string): ShouldAssertion; } From ef1741f3d614a6da73e3a46d4dc191def7e645a4 Mon Sep 17 00:00:00 2001 From: D062356 Date: Thu, 14 Jan 2016 08:48:25 -0800 Subject: [PATCH 3/8] Added missing indexOf function and constructor to buffer --- node/node-tests.ts | 10 ++++++++++ node/node.d.ts | 7 +++++++ 2 files changed, 17 insertions(+) diff --git a/node/node-tests.ts b/node/node-tests.ts index 9aebe5c53..8faf5fed6 100644 --- a/node/node-tests.ts +++ b/node/node-tests.ts @@ -134,6 +134,7 @@ function bufferTests() { var base64Buffer = new Buffer('','base64'); var octets: Uint8Array = null; var octetBuffer = new Buffer(octets); + var copiedBuffer = new Buffer(utf8Buffer); console.log(Buffer.isBuffer(octetBuffer)); console.log(Buffer.isEncoding('utf8')); console.log(Buffer.byteLength('xyz123')); @@ -159,6 +160,15 @@ function bufferTests() { // fill returns the input buffer. b.fill('a').fill('b'); + + { + let buffer = new Buffer('123'); + let index: number; + index = buffer.indexOf("23"); + index = buffer.indexOf("23", 1); + index = buffer.indexOf(23); + index = buffer.indexOf(buffer); + } } diff --git a/node/node.d.ts b/node/node.d.ts index a7f1a1617..928b823e5 100644 --- a/node/node.d.ts +++ b/node/node.d.ts @@ -113,6 +113,12 @@ declare var Buffer: { * @param array The octets to store. */ new (array: any[]): Buffer; + /** + * Copies the passed {buffer} data onto a new {Buffer} instance. + * + * @param buffer The buffer to copy. + */ + new (buffer: Buffer): Buffer; prototype: Buffer; /** * Returns true if {obj} is a Buffer @@ -395,6 +401,7 @@ interface NodeBuffer { writeDoubleLE(value: number, offset: number, noAssert?: boolean): number; writeDoubleBE(value: number, offset: number, noAssert?: boolean): number; fill(value: any, offset?: number, end?: number): Buffer; + indexOf(value: string | number | Buffer, byteOffset?: number): number; } /************************************************ From a1c9ad7d5be39cad7d32a725286b0769af567ad4 Mon Sep 17 00:00:00 2001 From: Jean-Philipe Pellerin Date: Thu, 14 Jan 2016 15:51:30 -0500 Subject: [PATCH 4/8] Added the object in the auth additional configuration options. These changes are based on the braking changes introduced in hapi 12.0.0. --- hapi/hapi.d.ts | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-) diff --git a/hapi/hapi.d.ts b/hapi/hapi.d.ts index b31c24b16..aa814fcc3 100644 --- a/hapi/hapi.d.ts +++ b/hapi/hapi.d.ts @@ -395,21 +395,19 @@ declare module "hapi" { 'required'authentication is required. 'optional'authentication is optional (must be valid if present). 'try'same as 'optional' but allows for invalid authentication. */ - mode: string; + mode?: string; /** a string array of strategy names in order they should be attempted.If only one strategy is used, strategy can be used instead with the single string value.Defaults to the default authentication strategy which is available only when a single strategy is configured. */ - strategies: string | Array; + strategies?: string | Array; /** if set, the payload (in requests other than 'GET' and 'HEAD') is authenticated after it is processed.Requires a strategy with payload authentication support (e.g.Hawk).Cannot be set to a value other than 'required' when the scheme sets the options.payload to true.Available values: falseno payload authentication.This is the default value. 'required'payload authentication required.This is the default value when the scheme sets options.payload to true. 'optional'payload authentication performed only when the client includes payload authentication information (e.g.hash attribute in Hawk). */ payload?: string; - /** the application scope required to access the route.Value can be a scope string or an array of scope strings.The authenticated credentials object scope property must contain at least one of the scopes defined to access the route.Set to false to remove scope requirements.Defaults to no scope required. */ - scope?: string|Array|boolean; - /** the required authenticated entity type.If set, must match the entity value of the authentication credentials.Available values: - anythe authentication can be on behalf of a user or application.This is the default value. - userthe authentication must be on behalf of a user. - appthe authentication must be on behalf of an application. */ - entity?: string; + /** + * an object or array of objects specifying the route access rules. Each rule is evaluated against an incoming + * request and access is granted if at least one rule matches. Each rule object must include at least one of: + */ + access?: IRouteAdditionalConfigurationAuthAccess | IRouteAdditionalConfigurationAuthAccess[]; }; /** an object passed back to the provided handler (via this) when called. */ bind?: any; @@ -640,6 +638,29 @@ declare module "hapi" { */ tags?: string[] } + + /** + * specifying the route access rules. Each rule is evaluated against an incoming request and access is granted if at least one rule matches + */ + export interface IRouteAdditionalConfigurationAuthAccess { + /** + * the application scope required to access the route. Value can be a scope string or an array of scope strings. + * The authenticated credentials object scope property must contain at least one of the scopes defined to access the route. + * If a scope string begins with a + character, that scope is required. If a scope string begins with a ! character, + * that scope is forbidden. For example, the scope ['!a', '+b', 'c', 'd'] means the incoming request credentials' + * scope must not include 'a', must include 'b', and must include on of 'c' or 'd'. You may also access properties + * on the request object (query and params} to populate a dynamic scope by using {} characters around the property name, + * such as 'user-{params.id}'. Defaults to false (no scope requirements). + */ + scope?: string|Array|boolean; + /** the required authenticated entity type. If set, must match the entity value of the authentication credentials. Available values: + * any - the authentication can be on behalf of a user or application. This is the default value. + * user - the authentication must be on behalf of a user which is identified by the presence of a user attribute in the credentials object returned by the authentication strategy. + * app - the authentication must be on behalf of an application which is identified by the lack of presence of a user attribute in the credentials object returned by the authentication strategy. + */ + entity?: string; + } + /** server.realm http://hapijs.com/api#serverrealm The realm object contains server-wide or plugin-specific state that can be shared across various methods. For example, when calling server.bind(), the active realm settings.bind property is set which is then used by routes and extensions added at the same level (server root or plugin). From 1e3e963bf5ea4f36e98a816caa971fe918b74897 Mon Sep 17 00:00:00 2001 From: Tanguy Krotoff Date: Fri, 15 Jan 2016 02:45:07 +0100 Subject: [PATCH 5/8] Options should be inside the namespace --- gulp-autoprefixer/gulp-autoprefixer.d.ts | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/gulp-autoprefixer/gulp-autoprefixer.d.ts b/gulp-autoprefixer/gulp-autoprefixer.d.ts index 4ab8cf40d..d372358eb 100644 --- a/gulp-autoprefixer/gulp-autoprefixer.d.ts +++ b/gulp-autoprefixer/gulp-autoprefixer.d.ts @@ -6,15 +6,15 @@ /// declare module "gulp-autoprefixer" { - interface Options { - browsers?: string[]; - cascade?: boolean; - remove?: boolean; + namespace autoPrefixer { + interface Options { + browsers?: string[]; + cascade?: boolean; + remove?: boolean; + } } - function autoPrefixer(opts?: Options): NodeJS.ReadWriteStream; - - namespace autoPrefixer {} + function autoPrefixer(opts?: autoPrefixer.Options): NodeJS.ReadWriteStream; export = autoPrefixer; } From f7c3fc2b5a7e469cde0df354838bdf1b889b06c5 Mon Sep 17 00:00:00 2001 From: Tanguy Krotoff Date: Fri, 15 Jan 2016 02:49:28 +0100 Subject: [PATCH 6/8] Options and SizeStream should be inside the namespace --- gulp-size/gulp-size.d.ts | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/gulp-size/gulp-size.d.ts b/gulp-size/gulp-size.d.ts index 022e9b171..ba13c55a2 100644 --- a/gulp-size/gulp-size.d.ts +++ b/gulp-size/gulp-size.d.ts @@ -6,20 +6,20 @@ /// declare module 'gulp-size' { - interface IOptions { - showFiles?: boolean; - gzip?: boolean; - title?: string; + namespace size { + interface Options { + showFiles?: boolean; + gzip?: boolean; + title?: string; + } + + interface SizeStream extends NodeJS.ReadWriteStream { + size: number; + prettySize: string; + } } - interface ISizeStream extends NodeJS.ReadWriteStream { - size: number; - prettySize: string; - } - - function size(options?: IOptions): ISizeStream; - - namespace size {} + function size(options?: size.Options): size.SizeStream; export = size; } From fc5ea7aac41189c376803e19a59e87ec167477b1 Mon Sep 17 00:00:00 2001 From: Tanguy Krotoff Date: Fri, 15 Jan 2016 02:50:07 +0100 Subject: [PATCH 7/8] Fix import --- gulp-rev-replace/gulp-rev-replace-tests.ts | 8 ++++---- gulp-rev-replace/gulp-rev-replace.d.ts | 20 +++++++++++--------- 2 files changed, 15 insertions(+), 13 deletions(-) diff --git a/gulp-rev-replace/gulp-rev-replace-tests.ts b/gulp-rev-replace/gulp-rev-replace-tests.ts index e7c5d9c18..7610183d8 100644 --- a/gulp-rev-replace/gulp-rev-replace-tests.ts +++ b/gulp-rev-replace/gulp-rev-replace-tests.ts @@ -3,10 +3,10 @@ /// /// -import gulp = require('gulp'); -import revReplace = require('gulp-rev-replace'); -import rev = require('gulp-rev'); -import useref = require('gulp-useref'); +import * as gulp from 'gulp'; +import * as revReplace from 'gulp-rev-replace'; +import * as rev from 'gulp-rev'; +import * as useref from 'gulp-useref'; gulp.task("index", () => { return gulp.src("src/index.html") diff --git a/gulp-rev-replace/gulp-rev-replace.d.ts b/gulp-rev-replace/gulp-rev-replace.d.ts index 3e683d183..6c258573d 100644 --- a/gulp-rev-replace/gulp-rev-replace.d.ts +++ b/gulp-rev-replace/gulp-rev-replace.d.ts @@ -6,16 +6,18 @@ /// declare module 'gulp-rev-replace' { - interface IOptions { - canonicalUris?: boolean; - replaceInExtensions?: Array; - prefix?: string; - manifest?: NodeJS.ReadWriteStream; - modifyUnreved?: Function; - modifyReved?: Function; + namespace revReplace { + interface Options { + canonicalUris?: boolean; + replaceInExtensions?: Array; + prefix?: string; + manifest?: NodeJS.ReadWriteStream; + modifyUnreved?: Function; + modifyReved?: Function; } + } - function revReplace(options?: IOptions): NodeJS.ReadWriteStream; + function revReplace(options?: revReplace.Options): NodeJS.ReadWriteStream; - export = revReplace; + export = revReplace; } From 0b23833fb157916c5e9eefdb06827a8a9fef69a2 Mon Sep 17 00:00:00 2001 From: Norgerman Date: Fri, 15 Jan 2016 10:58:26 +0800 Subject: [PATCH 8/8] add useQuerystring into request.CoreOptions --- request/request.d.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/request/request.d.ts b/request/request.d.ts index d47ed5f9a..4d51fd14b 100644 --- a/request/request.d.ts +++ b/request/request.d.ts @@ -110,6 +110,7 @@ declare module 'request' { passphrase?: string; ca?: Buffer; har?: HttpArchiveRequest; + useQuerystring?: boolean; } interface UriOptions {