Merge pull request #2374 from Bartvds/def/bufferstream

added some buffer/stream modules

JSONStream/JSONStream-tests.ts

@@ -0,0 +1,15 @@
+/// <reference path="JSONStream.d.ts" />
+
+import json = require('JSONStream');
+
+var read: NodeJS.ReadableStream;
+var write: NodeJS.WritableStream;
+
+read = read.pipe(json.parse('*'));
+read = read.pipe(json.parse(['foo/*', 'bar/*']));
+
+read = json.stringify();
+read = json.stringify('{', ',', '}');
+
+read = json.stringifyObject();
+read = json.stringifyObject('{', ',', '}');

JSONStream/JSONStream.d.ts

@@ -0,0 +1,22 @@
+// Type definitions for JSONStream v0.8.0
+// Project: http://github.com/dominictarr/JSONStream
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module 'JSONStream' {
+
+	export interface Options {
+		recurse: boolean;
+	}
+
+	export function parse(pattern: any): NodeJS.ReadWriteStream;
+	export function parse(patterns: any[]): NodeJS.ReadWriteStream;
+
+	export function stringify(): NodeJS.ReadWriteStream;
+	export function stringify(open: string, sep: string, close: string): NodeJS.ReadWriteStream;
+
+	export function stringifyObject(): NodeJS.ReadWriteStream;
+	export function stringifyObject(open: string, sep: string, close: string): NodeJS.ReadWriteStream;
+}

buffer-equal/buffer-equal.d.ts

@@ -1,5 +1,5 @@
 // Type definitions for buffer-equal 1.0 0
-// Project: https://github.com/chaijs/assertion-error
+// Project: https://github.com/substack/node-buffer-equal
 // Definitions by: Bart van der Schoor <https://github.com/Bartvds>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 

bufferstream/bufferstream-tests.ts

@@ -0,0 +1,14 @@
+/// <reference path="bufferstream.d.ts" />
+
+import BufferStream = require('bufferstream')
+
+var stream = new BufferStream({encoding:'utf8', size:'flexible'});
+stream.enable();
+stream.disable();
+stream.split('//', ':');
+stream.on('split', (chunk: any, token: any) => {
+	console.log("got '%s' by '%s'", chunk.toString(), token.toString())
+});
+stream.write("buffer:stream//23");
+console.log(stream.toString());
+

bufferstream/bufferstream.d.ts

@@ -0,0 +1,119 @@
+// Type definitions for bufferstream v0.6.2
+// Project: https://github.com/dodo/node-bufferstream
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module 'bufferstream' {
+	import stream = require('stream');
+
+	export = BufferStream;
+
+	class BufferStream extends stream.Duplex {
+		constructor(options?: BufferStream.Opts);
+
+		/*
+		 different buffer behaviors can be triggered by size:
+
+		 none when output drains, bufferstream drains too
+		 flexible buffers everthing that it gets and not piping out
+		 <number> TODO buffer has given size. buffers everthing until buffer is full. when buffer is full then the stream will drain
+		*/
+		setSize(size: string): void; // can be one of ['none', 'flexible', <number>]
+		setSize(size: number): void; // can be one of ['none', 'flexible', <number>]
+		/*
+		 enables stream buffering default
+		*/
+		enable(): void;
+		/*
+		 flushes buffer and disables stream buffering. BufferStream now pipes all data as long as the output accepting data. when the output is draining BufferStream will buffer all input temporary.
+
+		 token[s] buffer splitters (should be String or Buffer)
+
+		 disables given tokens. wont flush until no splitter tokens are left.
+		*/
+		disable(): void;
+		disable(token: string, ...tokens: string[]): void;
+		disable(tokens: string[]): void; // Array
+		disable(token: Buffer, ...tokens: Buffer[]): void;
+		disable(tokens: Buffer[]): void; // Array
+		/*
+		 each time BufferStream finds a splitter token in the input data it will emit a split event. this also works for binary data.
+
+		 token[s] buffer splitters (should be String or Buffer)
+		*/
+		split(token: string, ...tokens: string[]): void;
+		split(tokens: string[]): void; // Array
+		split(token: Buffer, ...tokens: Buffer[]): void;
+		split(tokens: Buffer[]): void; // Array
+		/*
+		 returns Buffer.
+		*/
+		getBuffer(): Buffer;
+		/*
+		 returns Buffer.
+		*/
+		buffer: Buffer;
+		/*
+		 shortcut for buffer.toString()
+		*/
+		toString(): string;
+		/*
+		 shortcut for buffer.length
+		*/
+		length: number;
+	}
+	module BufferStream {
+
+		export interface Opts {
+			/*
+			 default encoding for writing strings
+			*/
+			encoding?: string;
+			/*
+			 if true and the source is a child_process the stream will block the entire process (timeouts wont work anymore, but splitting and listening on data still works, because they work sync)
+			*/
+			blocking?: boolean;
+			/*
+			 defines buffer level or sets buffer to given size (see ↓setSize for more)
+			*/
+			size?: any;
+			/*
+			 immediately call disable
+			*/
+			disabled?: boolean;
+			/*
+			 short form for:
+				split(token, function (chunk) {emit('data', chunk)})
+			*/
+			// String or Buffer
+			split?: any;
+		}
+		export var fn: {warn: boolean};
+	}
+}
+
+declare module 'bufferstream/postbuffer' {
+	import http = require('http');
+	import BufferStream = require('bufferstream');
+
+	class PostBuffer extends BufferStream {
+		/*
+		 for if you want to get all the post data from a http server request and do some db reqeust before.
+
+		 http client buffer
+		*/
+		constructor(req: http.ServerRequest);
+		/*
+			set a callback to get all post data from a http server request
+		*/
+		onEnd(callback: (data: any) => void): void;
+		/*
+		 pumps data into another stream to allow incoming streams given options will be passed to Stream.pipe
+		*/
+		pipe(stream: NodeJS.WritableStream, options?: BufferStream.Opts): NodeJS.ReadableStream;
+	}
+
+	export = PostBuffer;
+}

deep-freeze/deep-freeze-tests.ts

@@ -0,0 +1,8 @@
+/// <reference path="deep-freeze.d.ts" />
+
+import df = require('deep-freeze');
+
+class Foo {
+	foo: string;
+}
+var foo:Foo = df(new Foo());

deep-freeze/deep-freeze.d.ts

@@ -0,0 +1,9 @@
+// Type definitions for deep-freeze
+// Project: https://github.com/substack/deep-freeze
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'deep-freeze' {
+	function df<T>(obj: T): T;
+	export = df;
+}

glob-stream/glob-stream-tests.ts

@@ -0,0 +1,12 @@
+/// <reference path="glob-stream" />
+
+import gs = require('glob-stream');
+
+var read: NodeJS.ReadableStream;
+
+read = gs.create('xx');
+read = gs.create('xx', {});
+read = gs.create(['xx'], {});
+read = gs.create(['xx'], {cwd: 'xx'});
+read = gs.create(['xx'], {base: 'xx'});
+read = gs.create(['xx'], {cwdbase: true});

glob-stream/glob-stream.d.ts

@@ -0,0 +1,26 @@
+// Type definitions for glob-stream v3.1.12
+// Project: http://github.com/wearefractal/glob-stream
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../glob/glob.d.ts" />
+
+declare module 'glob-stream' {
+	import glob = require('glob');
+
+	export interface Options extends glob.IOptions {
+		cwd?: string;
+		base?: string;
+		cwdbase?: boolean;
+	}
+
+	export interface Element {
+		cwd: string;
+		base: string;
+		path: string;
+	}
+
+	export function create(glob:string, opts?: Options): NodeJS.ReadableStream;
+	export function create(globs:string[], opts?: Options): NodeJS.ReadableStream;
+}