ckaczor/LaundryMonitor
1
0
Fork 0
mirror of https://github.com/ckaczor/LaundryMonitor.git synced 2026-01-13 17:22:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move project to GitHub and hide Telegram config

Browse Source
This commit is contained in:
Chris Kaczor
2018-03-26 15:39:27 -04:00
commit 74c384a652
26 changed files with 15047 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
node_modules/
release/

21
LICENSE.md Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2018 Chris Kaczor
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

11
README.md Normal file
View File

@@ -0,0 +1,11 @@
# LaundryMonitor
Monitors washing machine and dryer status.
## Authors
* **Chris Kaczor** - *Initial work* - https://github.com/ckaczor - https://chriskaczor.com
## License
This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

13
app/config.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
export interface IConfig {
port: number;
refreshInterval: number;
deviceDebounceInterval: number;
botToken: string;
chatId: string;
debugChatId: string;
debug: boolean;
enableTelegram: boolean;
}

17
app/config.ts Normal file
View File

@@ -0,0 +1,17 @@
import { IConfig } from './config.d';
class Config implements IConfig {
port = 80;
refreshInterval = 500;
deviceDebounceInterval = 10000;
botToken = 'BOT-TOKEN';
chatId = 'CHAT-ID';
debugChatId = 'DEBUG-CHAT-ID';
debug = false;
enableTelegram = true;
}
export const config = new Config();

100
app/device.ts Normal file
View File

@@ -0,0 +1,100 @@
import _ = require('underscore');
import bunyan = require('bunyan');
import gpio = require('onoff');
export var log: bunyan.Logger;
export class DeviceConfiguration {
key: string;
pin: number;
}
export class DeviceListConfiguration {
pollInterval: number;
deviceConfiguration: Array<DeviceConfiguration>;
deviceUpdateCallback: (device: Device, initialUpdate: boolean) => void;
}
export class DeviceList {
private deviceList: { [key: string]: Device };
constructor(private configuration: DeviceListConfiguration) {
this.deviceList = {};
configuration.deviceConfiguration.forEach((deviceConfiguration: DeviceConfiguration) => {
this.createDevice(deviceConfiguration.key, deviceConfiguration.pin);
});
this.update(true);
setInterval(this.update.bind(this), configuration.pollInterval);
}
private createDevice(key: string, pin: number): Device {
const device = new Device(key, pin);
this.deviceList[key] = device;
return device;
}
getDevices(): Array<Device> {
return _.toArray<Device>(this.deviceList);
}
getStatus(): any {
var status: { [key: string]: boolean } = {};
_.each(this.deviceList, (device: Device) => {
status[device.key] = device.value;
});
return status;
}
private update(initialUpdate: boolean = false) {
_.each(this.deviceList, (device: Device) => {
var deviceChanged = device.update();
if (deviceChanged) {
this.configuration.deviceUpdateCallback(device, initialUpdate);
if (log) {
log.info(`DeviceList.Update - ${device.toString()}`);
}
}
});
}
}
export class Device {
private gpioPin: gpio.Gpio;
value: boolean;
constructor(public key: string, pin: number) {
this.gpioPin = new gpio.Gpio(pin, 'in', 'both');
}
toString(): string {
return `Device: ${this.key} = ${this.value}`;
}
getStatus(): any {
const status: { [key: string]: boolean } = {};
status[this.key] = this.value;
return status;
}
update(): boolean {
const newValue = this.gpioPin.readSync() === 0;
const changed = (this.value !== newValue);
this.value = newValue;
return changed;
}
}

164
app/main.ts Normal file
View File

@@ -0,0 +1,164 @@
/// <reference path="../typings/express/express.d.ts" />
/// <reference path="../typings/onoff/onoff.d.ts" />
/// <reference path="../typings/request/request.d.ts" />
/// <reference path="../typings/tsd.d.ts" />
// ---
import os = require('os');
import bunyan = require('bunyan');
import express = require('express');
import http = require('http');
import socketio = require('socket.io');
import request = require('request');
import device = require('./device');
import Device = device.Device;
import config = require('./config');
import Config = config.config;
var app = express();
var server = http.createServer(app);
var io = socketio(server);
// ---
var log = bunyan.createLogger({
name: 'laundry_monitor',
streams: [
{
type: 'rotating-file',
path: '/var/log/laundry_monitor.log',
period: '1d',
count: 3
},
{
stream: process.stdout
}
]
});
device.log = log;
// ---
log.info('Setting up devices');
var deviceListConfiguration: device.DeviceListConfiguration = {
pollInterval: Config.refreshInterval,
deviceConfiguration: [{ key: 'washer', pin: 413 }, { key: 'dryer', pin: 415 }],
deviceUpdateCallback: (device: Device, initialUpdate: boolean) => {
if (initialUpdate) {
return;
}
queueDeviceUpdate(device, undefined, 'The {name} is now {status}.');
}
};
var devices = new device.DeviceList(deviceListConfiguration);
// ---
const deviceLastState: { [key: string]: boolean } = {};
const deviceUpdateQueue: { [key: string]: number } = {};
function queueDeviceUpdate(device: Device, header: string, deviceTemplate: string) {
if (deviceUpdateQueue[device.key]) {
log.info(`queueDeviceUpdate - Stopping old timer for device: ${device.key}`);
clearTimeout(deviceUpdateQueue[device.key]);
}
log.info(`queueDeviceUpdate - Starting new timer for device: ${device.key}`);
deviceUpdateQueue[device.key] = setTimeout(() => {
if (deviceLastState[device.key] !== device.value) {
sendTelegramDeviceUpdate([device], header, deviceTemplate);
emitStatus(device.getStatus());
} else {
log.info(`queueDeviceUpdate - No change for device: ${device.key}`);
}
delete deviceUpdateQueue[device.key];
}, Config.deviceDebounceInterval) as any;
}
function sendTelegramDeviceUpdate(devices: Array<Device>, header: string, deviceTemplate: string) {
let telegramMessage = header || '';
devices.forEach((device: Device) => {
deviceLastState[device.key] = device.value;
const deviceLine = deviceTemplate.replace('{name}', device.key).replace('{status}', device.value ? 'ON' : 'OFF');
telegramMessage += `${deviceLine}\n`;
});
if (telegramMessage.length > 0) {
sendTelegramMessage(telegramMessage);
}
}
function sendTelegramMessage(message: string) {
log.info(`Telegram message: ${message}`);
if (!Config.enableTelegram) {
return;
}
const sendChatId = Config.debug ? Config.debugChatId : Config.chatId;
const url = `https://api.telegram.org/bot${Config.botToken}/sendMessage?chat_id=${sendChatId}&text=${encodeURIComponent(message)}`;
request(url);
}
// ---
log.info('Starting web server');
app.get('/getStatus', (request, response) => {
const data = devices.getStatus();
response.end(JSON.stringify(data));
});
server.listen(Config.port, () => {
const host = os.hostname();
log.info(`Listening at http://${host}:${Config.port}`);
});
// ---
log.info('Starting socket.io server');
function emitStatus(status: any) {
const socketMessage = JSON.stringify(status);
log.info(`emitStatus: ${socketMessage}`);
io.emit('status', socketMessage);
}
io.on('connection', (socket: SocketIO.Socket) => {
log.info('socket.io: connection');
socket.on('getStatus', () => {
log.info('socket.io: getStatus');
emitStatus(devices.getStatus());
});
socket.on('disconnect', () => {
log.info('socket.io: disconnect');
});
});
// ---
log.info('Ready');
emitStatus(devices.getStatus());
sendTelegramDeviceUpdate(devices.getDevices(), 'Powering up!\n\n', 'The {name} is currently {status}.');

44
gulpfile.js Normal file
View File

@@ -0,0 +1,44 @@
var gulp = require('gulp');
var ts = require('gulp-typescript');
var merge = require('merge2');
var runSequence = require('run-sequence');
var dirSync = require('gulp-directory-sync');
gulp.task('transpile', function () {
var tsResult = gulp.src('app/*.ts')
.pipe(ts({
declarationFiles: false,
noResolve: false,
noImplicitAny: true,
module: 'commonjs',
moduleResolution: 'node',
outDir: 'release'
}));
return merge([
tsResult.dts.pipe(gulp.dest('release/definitions')),
tsResult.js.pipe(gulp.dest('release'))
]);
});
gulp.task('watch', function () {
gulp.watch(['app/**/*', 'scripts/**/*'], ['build']);
});
gulp.task('deploy', function () {
return gulp.src('')
.pipe(dirSync('release', '/mnt/chip/laundry_monitor', { printSummary: true, ignore: ['node_modules', '.foreverignore'] }))
.on('error', function () { });
});
gulp.task('package', function () {
gulp.src('package.json').pipe(gulp.dest('release'));
gulp.src('scripts/*.sh').pipe(gulp.dest('release'));
gulp.src('app/index.html').pipe(gulp.dest('release'));
});
gulp.task('build', function (done) {
runSequence('transpile', 'package', 'deploy', function () {
done();
});
});

4471
package-lock.json generated Normal file
View File

File diff suppressed because it is too large Load Diff

27
package.json Normal file
View File

@@ -0,0 +1,27 @@
{
"name": "laundry-monitor",
"version": "1.0.0",
"description": "",
"main": "main.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Chris Kaczor",
"license": "ISC",
"devDependencies": {
"gulp": "^3.9.1",
"gulp-directory-sync": "^1.2.3",
"gulp-typescript": "^3.1.2",
"merge2": "^1.0.2",
"run-sequence": "^1.2.2",
"typescript": "^2.0.9"
},
"dependencies": {
"bunyan": "^1.8.4",
"express": "^4.14.0",
"onoff": "^1.1.1",
"request": "^2.78.0",
"socket.io": "^1.5.1",
"underscore": "^1.8.3"
}
}

2
scripts/debug.sh Normal file
View File

@@ -0,0 +1,2 @@
touch /home/ckaczor/laundry_monitor/.foreverignore
sudo forever --minUptime 1000 --spinSleepTime 1000 --watch --watchIgnore *.html --watchDirectory /home/ckaczor/laundry_monitor /home/ckaczor/laundry_monitor/main.js | bunyan

2
scripts/start.sh Normal file
View File

@@ -0,0 +1,2 @@
touch /home/ckaczor/laundry_monitor/.foreverignore
sudo forever start --minUptime 1000 --spinSleepTime 1000 --watch --watchIgnore *.html --watchDirectory /home/ckaczor/laundry_monitor /home/ckaczor/laundry_monitor/main.js > /dev/null

7
tsconfig.json Normal file
View File

@@ -0,0 +1,7 @@
{
"compilerOptions": {
"target": "es5",
"module": "commonjs",
"sourceMap": true
}
}

39
tsd.json Normal file
View File

@@ -0,0 +1,39 @@
{
"version": "v4",
"repo": "borisyankov/DefinitelyTyped",
"ref": "master",
"path": "typings",
"bundle": "typings/tsd.d.ts",
"installed": {
"node/node.d.ts": {
"commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
},
"socket.io/socket.io.d.ts": {
"commit": "7fffbd3e040a93c244777e3be04cd6223ac69301"
},
"bunyan/bunyan.d.ts": {
"commit": "7fffbd3e040a93c244777e3be04cd6223ac69301"
},
"express/express.d.ts": {
"commit": "7b3d5a6ea5acda4a81f71309f1cc62354e63b681"
},
"mime/mime.d.ts": {
"commit": "7b3d5a6ea5acda4a81f71309f1cc62354e63b681"
},
"serve-static/serve-static.d.ts": {
"commit": "7b3d5a6ea5acda4a81f71309f1cc62354e63b681"
},
"underscore/underscore.d.ts": {
"commit": "86dbea8fc37d9473fee465da4f0a21bea4f8cbd9"
},
"onoff/onoff.d.ts": {
"commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
},
"request/request.d.ts": {
"commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
},
"form-data/form-data.d.ts": {
"commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
}
}
}

56
tslint.json Normal file
View File

@@ -0,0 +1,56 @@
{
"rules": {
"class-name": true,
"comment-format": [
true,
"check-space"
],
"indent": [
true,
"tabs"
],
"no-duplicate-variable": true,
"no-eval": true,
"no-internal-module": false,
"no-trailing-whitespace": false,
"no-var-keyword": true,
"one-line": [
true,
"check-open-brace",
"check-whitespace"
],
"quotemark": [
true,
"single"
],
"semicolon": [
true
],
"triple-equals": [
true,
"allow-null-check"
],
"typedef-whitespace": [
true,
{
"call-signature": "nospace",
"index-signature": "nospace",
"parameter": "nospace",
"property-declaration": "nospace",
"variable-declaration": "nospace"
}
],
"variable-name": [
true,
"ban-keywords"
],
"whitespace": [
true,
"check-branch",
"check-decl",
"check-operator",
"check-separator",
"check-type"
]
}
}

102
typings/bunyan/bunyan.d.ts vendored Normal file
View File

@@ -0,0 +1,102 @@
// Type definitions for node-bunyan
// Project: https://github.com/trentm/node-bunyan
// Definitions by: Alex Mikhalev <https://github.com/amikhalev>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
/// <reference path="../node/node.d.ts" />
declare module "bunyan" {
import { EventEmitter } from 'events';
class Logger extends EventEmitter {
constructor(options:LoggerOptions);
addStream(stream:Stream):void;
addSerializers(serializers:Serializers):void;
child(options:LoggerOptions, simple?:boolean):Logger;
child(obj:Object, simple?:boolean):Logger;
reopenFileStreams():void;
level():string|number;
level(value: number | string):void;
levels(name: number | string, value: number | string):void;
trace(error:Error, format?:any, ...params:any[]):void;
trace(buffer:Buffer, format?:any, ...params:any[]):void;
trace(obj:Object, format?:any, ...params:any[]):void;
trace(format:string, ...params:any[]):void;
debug(error:Error, format?:any, ...params:any[]):void;
debug(buffer:Buffer, format?:any, ...params:any[]):void;
debug(obj:Object, format?:any, ...params:any[]):void;
debug(format:string, ...params:any[]):void;
info(error:Error, format?:any, ...params:any[]):void;
info(buffer:Buffer, format?:any, ...params:any[]):void;
info(obj:Object, format?:any, ...params:any[]):void;
info(format:string, ...params:any[]):void;
warn(error:Error, format?:any, ...params:any[]):void;
warn(buffer:Buffer, format?:any, ...params:any[]):void;
warn(obj:Object, format?:any, ...params:any[]):void;
warn(format:string, ...params:any[]):void;
error(error:Error, format?:any, ...params:any[]):void;
error(buffer:Buffer, format?:any, ...params:any[]):void;
error(obj:Object, format?:any, ...params:any[]):void;
error(format:string, ...params:any[]):void;
fatal(error:Error, format?:any, ...params:any[]):void;
fatal(buffer:Buffer, format?:any, ...params:any[]):void;
fatal(obj:Object, format?:any, ...params:any[]):void;
fatal(format:string, ...params:any[]):void;
}
interface LoggerOptions {
name: string;
streams?: Stream[];
level?: string | number;
stream?: NodeJS.WritableStream;
serializers?: Serializers;
src?: boolean;
}
interface Serializers {
[key:string]: (input:any) => string;
}
interface Stream {
type?: string;
level?: number | string;
path?: string;
stream?: NodeJS.WritableStream | Stream;
closeOnExit?: boolean;
period?: string;
count?: number;
}
export var stdSerializers:Serializers;
export var TRACE:number;
export var DEBUG:number;
export var INFO:number;
export var WARN:number;
export var ERROR:number;
export var FATAL:number;
export function resolveLevel(value: number | string):number;
export function createLogger(options:LoggerOptions):Logger;
class RingBuffer extends EventEmitter {
constructor(options:RingBufferOptions);
writable:boolean;
records:any[];
write(record:any):void;
end(record?:any):void;
destroy():void;
destroySoon():void;
}
interface RingBufferOptions {
limit?: number;
}
export function safeCycles():(key:string, value:any) => any;
}

1076
typings/express/express.d.ts vendored Normal file
View File

File diff suppressed because it is too large Load Diff

25
typings/form-data/form-data.d.ts vendored Normal file
View File

@@ -0,0 +1,25 @@
// Type definitions for form-data
// Project: https://github.com/felixge/node-form-data
// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Leon Yu <https://github.com/leonyu>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// Imported from: https://github.com/soywiz/typescript-node-definitions/form-data.d.ts
declare module "form-data" {
class FormData {
append(key: string, value: any, options?: any): void;
getHeaders(): FormData.Dictionary<string>;
// TODO expand pipe
pipe(to: any): any;
submit(params: string | Object, callback: (error: any, response: any) => void): any;
getBoundary(): string;
}
namespace FormData {
interface Dictionary<T> {
[key: string]: T;
}
}
export = FormData;
}

20
typings/mime/mime.d.ts vendored Normal file
View File

@@ -0,0 +1,20 @@
// Type definitions for mime
// Project: https://github.com/broofa/node-mime
// Definitions by: Jeff Goddard <https://github.com/jedigo>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
// Imported from: https://github.com/soywiz/typescript-node-definitions/mime.d.ts
declare module "mime" {
export function lookup(path: string): string;
export function extension(mime: string): string;
export function load(filepath: string): void;
export function define(mimes: Object): void;
interface Charsets {
lookup(mime: string): string;
}
export var charsets: Charsets;
export var default_type: string;
}

3949
typings/node/node.d.ts vendored Normal file
View File

File diff suppressed because it is too large Load Diff

55
typings/onoff/onoff.d.ts vendored Normal file
View File

@@ -0,0 +1,55 @@
// Type definitions for onoff
// Project: https://github.com/fivdi/onoff
// Definitions by: Marcel Ernst <https://github.com/marcel-ernst>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference path="../node/node.d.ts" />
declare namespace __ONOFF {
var version:string;
interface GpioOptions {
debounceTimeout:number;
}
class Gpio {
constructor(gpio:number, direction:string);
constructor(gpio:number, direction:string, edge:string);
constructor(gpio:number, direction:string, edge:string, options:GpioOptions);
constructor(gpio:number, direction:string, options:GpioOptions);
gpio:number
gpioPath:string;
opts:GpioOptions;
readBuffer:Buffer;
listeners:Array<(error:Error, value:number) => void>;
valueFd:number;
read(cb:(err:Error, value:number) => void):void;
readSync():number;
write(value:number, cb:(err:Error, value:number) => void):void;
writeSync(value:number):void;
watch(cb:(error:Error, value:number) => void):void;
unwatch():void;
unwatch(cb:(error:Error, value:number) => void):void;
unwatchAll():void;
direction():string;
setDirection(value:string):void;
edge():string;
setEdge(value:string):void;
options():GpioOptions;
unexport():void;
}
}
declare module "onoff" {
export = __ONOFF;
}

262
typings/request/request.d.ts vendored Normal file
View File

@@ -0,0 +1,262 @@
// Type definitions for request
// Project: https://github.com/request/request
// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, bonnici <https://github.com/bonnici>, Bart van der Schoor <https://github.com/Bartvds>, Joe Skeen <http://github.com/joeskeen>, Christopher Currens <https://github.com/ccurrens>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// Imported from: https://github.com/soywiz/typescript-node-definitions/d.ts
/// <reference path="../node/node.d.ts" />
/// <reference path="../form-data/form-data.d.ts" />
declare module 'request' {
import stream = require('stream');
import http = require('http');
import https = require('https');
import url = require('url');
import fs = require('fs');
import FormData = require('form-data');
namespace request {
export interface RequestAPI<TRequest extends Request,
TOptions extends CoreOptions,
TUriUrlOptions> {
defaults(options: TOptions): RequestAPI<TRequest, TOptions, RequiredUriUrl>;
defaults(options: RequiredUriUrl & TOptions): DefaultUriUrlRequestApi<TRequest, TOptions, OptionalUriUrl>;
(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
(uri: string, callback?: RequestCallback): TRequest;
(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
get(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
get(uri: string, callback?: RequestCallback): TRequest;
get(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
post(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
post(uri: string, callback?: RequestCallback): TRequest;
post(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
put(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
put(uri: string, callback?: RequestCallback): TRequest;
put(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
head(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
head(uri: string, callback?: RequestCallback): TRequest;
head(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
patch(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
patch(uri: string, callback?: RequestCallback): TRequest;
patch(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
del(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
del(uri: string, callback?: RequestCallback): TRequest;
del(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
forever(agentOptions: any, optionsArg: any): TRequest;
jar(): CookieJar;
cookie(str: string): Cookie;
initParams: any;
debug: boolean;
}
interface DefaultUriUrlRequestApi<TRequest extends Request,
TOptions extends CoreOptions,
TUriUrlOptions> extends RequestAPI<TRequest, TOptions, TUriUrlOptions> {
defaults(options: TOptions): DefaultUriUrlRequestApi<TRequest, TOptions, OptionalUriUrl>;
(): TRequest;
get(): TRequest;
post(): TRequest;
put(): TRequest;
head(): TRequest;
patch(): TRequest;
del(): TRequest;
}
interface CoreOptions {
baseUrl?: string;
callback?: (error: any, response: http.IncomingMessage, body: any) => void;
jar?: any; // CookieJar
formData?: any; // Object
form?: any; // Object or string
auth?: AuthOptions;
oauth?: OAuthOptions;
aws?: AWSOptions;
hawk?: HawkOptions;
qs?: any;
json?: any;
multipart?: RequestPart[] | Multipart;
agent?: http.Agent | https.Agent;
agentOptions?: any;
agentClass?: any;
forever?: any;
host?: string;
port?: number;
method?: string;
headers?: Headers;
body?: any;
followRedirect?: boolean | ((response: http.IncomingMessage) => boolean);
followAllRedirects?: boolean;
maxRedirects?: number;
encoding?: string;
pool?: any;
timeout?: number;
proxy?: any;
strictSSL?: boolean;
gzip?: boolean;
preambleCRLF?: boolean;
postambleCRLF?: boolean;
key?: Buffer;
cert?: Buffer;
passphrase?: string;
ca?: string | Buffer | string[] | Buffer[];
har?: HttpArchiveRequest;
useQuerystring?: boolean;
}
interface UriOptions {
uri: string;
}
interface UrlOptions {
url: string;
}
export type RequiredUriUrl = UriOptions | UrlOptions;
interface OptionalUriUrl {
uri?: string;
url?: string;
}
export type OptionsWithUri = UriOptions & CoreOptions;
export type OptionsWithUrl = UrlOptions & CoreOptions;
export type Options = OptionsWithUri | OptionsWithUrl;
export interface RequestCallback {
(error: any, response: http.IncomingMessage, body: any): void;
}
export interface HttpArchiveRequest {
url?: string;
method?: string;
headers?: NameValuePair[];
postData?: {
mimeType?: string;
params?: NameValuePair[];
}
}
export interface NameValuePair {
name: string;
value: string;
}
export interface Multipart {
chunked?: boolean;
data?: {
'content-type'?: string,
body: string
}[];
}
export interface RequestPart {
headers?: Headers;
body: any;
}
export interface Request extends stream.Stream {
readable: boolean;
writable: boolean;
getAgent(): http.Agent;
//start(): void;
//abort(): void;
pipeDest(dest: any): void;
setHeader(name: string, value: string, clobber?: boolean): Request;
setHeaders(headers: Headers): Request;
qs(q: Object, clobber?: boolean): Request;
form(): FormData;
form(form: any): Request;
multipart(multipart: RequestPart[]): Request;
json(val: any): Request;
aws(opts: AWSOptions, now?: boolean): Request;
auth(username: string, password: string, sendInmediately?: boolean, bearer?: string): Request;
oauth(oauth: OAuthOptions): Request;
jar(jar: CookieJar): Request;
on(event: string, listener: Function): this;
on(event: 'request', listener: (req: http.ClientRequest) => void): this;
on(event: 'response', listener: (resp: http.IncomingMessage) => void): this;
on(event: 'data', listener: (data: Buffer | string) => void): this;
on(event: 'error', listener: (e: Error) => void): this;
on(event: 'complete', listener: (resp: http.IncomingMessage, body?: string | Buffer) => void): this;
write(buffer: Buffer, cb?: Function): boolean;
write(str: string, cb?: Function): boolean;
write(str: string, encoding: string, cb?: Function): boolean;
write(str: string, encoding?: string, fd?: string): boolean;
end(): void;
end(chunk: Buffer, cb?: Function): void;
end(chunk: string, cb?: Function): void;
end(chunk: string, encoding: string, cb?: Function): void;
pause(): void;
resume(): void;
abort(): void;
destroy(): void;
toJSON(): Object;
}
export interface Headers {
[key: string]: any;
}
export interface AuthOptions {
user?: string;
username?: string;
pass?: string;
password?: string;
sendImmediately?: boolean;
bearer?: string;
}
export interface OAuthOptions {
callback?: string;
consumer_key?: string;
consumer_secret?: string;
token?: string;
token_secret?: string;
verifier?: string;
}
export interface HawkOptions {
credentials: any;
}
export interface AWSOptions {
secret: string;
bucket?: string;
}
export interface CookieJar {
setCookie(cookie: Cookie, uri: string | url.Url, options?: any): void
getCookieString(uri: string | url.Url): string
getCookies(uri: string | url.Url): Cookie[]
}
export interface CookieValue {
name: string;
value: any;
httpOnly: boolean;
}
export interface Cookie extends Array<CookieValue> {
constructor(name: string, req: Request): void;
str: string;
expires: Date;
path: string;
toString(): string;
}
}
var request: request.RequestAPI<request.Request, request.CoreOptions, request.RequiredUriUrl>;
export = request;
}

86
typings/serve-static/serve-static.d.ts vendored Normal file
View File

@@ -0,0 +1,86 @@
// Type definitions for serve-static 1.7.1
// Project: https://github.com/expressjs/serve-static
// Definitions by: Uros Smolnik <https://github.com/urossmolnik/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
/* =================== USAGE ===================
import * as serveStatic from "serve-static";
app.use(serveStatic("public/ftp", {"index": ["default.html", "default.htm"]}))
=============================================== */
/// <reference path="../express/express.d.ts" />
/// <reference path="../mime/mime.d.ts" />
declare module "serve-static" {
import * as express from "express";
/**
* Create a new middleware function to serve files from within a given root directory.
* The file to serve will be determined by combining req.url with the provided root directory.
* When a file is not found, instead of sending a 404 response, this module will instead call next() to move on to the next middleware, allowing for stacking and fall-backs.
*/
function serveStatic(root: string, options?: {
/**
* Set how "dotfiles" are treated when encountered. A dotfile is a file or directory that begins with a dot (".").
* Note this check is done on the path itself without checking if the path actually exists on the disk.
* If root is specified, only the dotfiles above the root are checked (i.e. the root itself can be within a dotfile when when set to "deny").
* The default value is 'ignore'.
* 'allow' No special treatment for dotfiles
* 'deny' Send a 403 for any request for a dotfile
* 'ignore' Pretend like the dotfile does not exist and call next()
*/
dotfiles?: string;
/**
* Enable or disable etag generation, defaults to true.
*/
etag?: boolean;
/**
* Set file extension fallbacks. When set, if a file is not found, the given extensions will be added to the file name and search for.
* The first that exists will be served. Example: ['html', 'htm'].
* The default value is false.
*/
extensions?: string[];
/**
* By default this module will send "index.html" files in response to a request on a directory.
* To disable this set false or to supply a new index pass a string or an array in preferred order.
*/
index?: boolean|string|string[];
/**
* Enable or disable Last-Modified header, defaults to true. Uses the file system's last modified value.
*/
lastModified?: boolean;
/**
* Provide a max-age in milliseconds for http caching, defaults to 0. This can also be a string accepted by the ms module.
*/
maxAge?: number|string;
/**
* Redirect to trailing "/" when the pathname is a dir. Defaults to true.
*/
redirect?: boolean;
/**
* Function to set custom headers on response. Alterations to the headers need to occur synchronously.
* The function is called as fn(res, path, stat), where the arguments are:
* res the response object
* path the file path that is being sent
* stat the stat object of the file that is being sent
*/
setHeaders?: (res: express.Response, path: string, stat: any) => any;
}): express.Handler;
import * as m from "mime";
module serveStatic {
var mime: typeof m;
}
export = serveStatic;
}

857
typings/socket.io/socket.io.d.ts vendored Normal file
View File

@@ -0,0 +1,857 @@
// Type definitions for socket.io 1.4.4
// Project: http://socket.io/
// Definitions by: PROGRE <https://github.com/progre/>, Damian Connolly <https://github.com/divillysausages/>, Florent Poujol <https://github.com/florentpoujol/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
///<reference path='../node/node.d.ts' />
declare module 'socket.io' {
var server: SocketIOStatic;
export = server;
}
interface SocketIOStatic {
/**
* Default Server constructor
*/
(): SocketIO.Server;
/**
* Creates a new Server
* @param srv The HTTP server that we're going to bind to
* @param opts An optional parameters object
*/
(srv: any, opts?: SocketIO.ServerOptions): SocketIO.Server;
/**
* Creates a new Server
* @param port A port to bind to, as a number, or a string
* @param An optional parameters object
*/
(port: string|number, opts?: SocketIO.ServerOptions): SocketIO.Server;
/**
* Creates a new Server
* @param A parameters object
*/
(opts: SocketIO.ServerOptions): SocketIO.Server;
/**
* Backwards compatibility
* @see io().listen()
*/
listen: SocketIOStatic;
}
declare module SocketIO {
interface Server {
/**
* A dictionary of all the namespaces currently on this Server
*/
nsps: {[namespace: string]: Namespace};
/**
* The default '/' Namespace
*/
sockets: Namespace;
/**
* Sets the 'json' flag when emitting an event
*/
json: Server;
/**
* Server request verification function, that checks for allowed origins
* @param req The http.IncomingMessage request
* @param fn The callback to be called. It should take one parameter, err,
* which will be null if there was no problem, and one parameter, success,
* of type boolean
*/
checkRequest( req:any, fn:( err: any, success: boolean ) => void ):void;
/**
* Gets whether we're serving the client.js file or not
* @default true
*/
serveClient(): boolean;
/**
* Sets whether we're serving the client.js file or not
* @param v True if we want to serve the file, false otherwise
* @default true
* @return This Server
*/
serveClient( v: boolean ): Server;
/**
* Gets the client serving path
* @default '/socket.io'
*/
path(): string;
/**
* Sets the client serving path
* @param v The path to serve the client file on
* @default '/socket.io'
* @return This Server
*/
path( v: string ): Server;
/**
* Gets the adapter that we're going to use for handling rooms
* @default typeof Adapter
*/
adapter(): any;
/**
* Sets the adapter (class) that we're going to use for handling rooms
* @param v The class for the adapter to create
* @default typeof Adapter
* @return This Server
*/
adapter( v: any ): Server;
/**
* Gets the allowed origins for requests
* @default "*:*"
*/
origins(): string;
/**
* Sets the allowed origins for requests
* @param v The allowed origins, in host:port form
* @default "*:*"
* return This Server
*/
origins( v: string ): Server;
/**
* Attaches socket.io to a server
* @param srv The http.Server that we want to attach to
* @param opts An optional parameters object
* @return This Server
*/
attach( srv: any, opts?: ServerOptions ): Server;
/**
* Attaches socket.io to a port
* @param port The port that we want to attach to
* @param opts An optional parameters object
* @return This Server
*/
attach( port: number, opts?: ServerOptions ): Server;
/**
* @see attach( srv, opts )
*/
listen( srv: any, opts?: ServerOptions ): Server;
/**
* @see attach( port, opts )
*/
listen( port: number, opts?: ServerOptions ): Server;
/**
* Binds socket.io to an engine.io intsance
* @param src The Engine.io (or compatible) server to bind to
* @return This Server
*/
bind( srv: any ): Server;
/**
* Called with each incoming connection
* @param socket The Engine.io Socket
* @return This Server
*/
onconnection( socket: any ): Server;
/**
* Looks up/creates a Namespace
* @param nsp The name of the NameSpace to look up/create. Should start
* with a '/'
* @return The Namespace
*/
of( nsp: string ): Namespace;
/**
* Closes the server connection
*/
close():void;
/**
* The event fired when we get a new connection
* @param event The event being fired: 'connection'
* @param listener A listener that should take one parameter of type Socket
* @return The default '/' Namespace
*/
on( event: 'connection', listener: ( socket: Socket ) => void ): Namespace;
/**
* @see on( 'connection', listener )
*/
on( event: 'connect', listener: ( socket: Socket ) => void ): Namespace;
/**
* Base 'on' method to add a listener for an event
* @param event The event that we want to add a listener for
* @param listener The callback to call when we get the event. The parameters
* for the callback depend on the event
* @return The default '/' Namespace
*/
on( event: string, listener: Function ): Namespace;
/**
* Targets a room when emitting to the default '/' Namespace
* @param room The name of the room that we're targeting
* @return The default '/' Namespace
*/
to( room: string ): Namespace;
/**
* @see to( room )
*/
in( room: string ): Namespace;
/**
* Registers a middleware function, which is a function that gets executed
* for every incoming Socket, on the default '/' Namespace
* @param fn The function to call when we get a new incoming socket. It should
* take one parameter of type Socket, and one callback function to call to
* execute the next middleware function. The callback can take one optional
* parameter, err, if there was an error. Errors passed to middleware callbacks
* are sent as special 'error' packets to clients
* @return The default '/' Namespace
*/
use( fn: ( socket:Socket, fn: ( err?: any ) => void ) =>void ): Namespace;
/**
* Emits an event to the default Namespace
* @param event The event that we want to emit
* @param args Any number of optional arguments to pass with the event. If the
* last argument is a function, it will be called as an ack. The ack should
* take whatever data was sent with the packet
* @return The default '/' Namespace
*/
emit( event: string, ...args: any[]): Namespace;
/**
* Sends a 'message' event
* @see emit( event, ...args )
* @return The default '/' Namespace
*/
send( ...args: any[] ): Namespace;
/**
* @see send( ...args )
*/
write( ...args: any[] ): Namespace;
/**
* Gets a list of clients
* @return The default '/' Namespace
*/
clients( ...args: any[] ): Namespace;
/**
* Sets the compress flag
* @return The default '/' Namespace
*/
compress( ...args: any[] ): Namespace;
}
/**
* Options to pass to our server when creating it
*/
interface ServerOptions {
/**
* The path to server the client file to
* @default '/socket.io'
*/
path?: string;
/**
* Should we serve the client file?
* @default true
*/
serveClient?: boolean;
/**
* The adapter to use for handling rooms. NOTE: this should be a class,
* not an object
* @default typeof Adapter
*/
adapter?: Adapter;
/**
* Accepted origins
* @default '*:*'
*/
origins?: string;
/**
* How many milliseconds without a pong packed to consider the connection closed (engine.io)
* @default 60000
*/
pingTimeout?: number;
/**
* How many milliseconds before sending a new ping packet (keep-alive) (engine.io)
* @default 25000
*/
pingInterval?: number;
/**
* How many bytes or characters a message can be when polling, before closing the session
* (to avoid Dos) (engine.io)
* @default 10E7
*/
maxHttpBufferSize?: number;
/**
* A function that receives a given handshake or upgrade request as its first parameter,
* and can decide whether to continue or not. The second argument is a function that needs
* to be called with the decided information: fn( err, success ), where success is a boolean
* value where false means that the request is rejected, and err is an error code (engine.io)
* @default null
*/
allowRequest?: (request:any, callback: (err: number, success: boolean) => void) => void;
/**
* Transports to allow connections to (engine.io)
* @default ['polling','websocket']
*/
transports?: string[];
/**
* Whether to allow transport upgrades (engine.io)
* @default true
*/
allowUpgrades?: boolean;
/**
* parameters of the WebSocket permessage-deflate extension (see ws module).
* Set to false to disable (engine.io)
* @default true
*/
perMessageDeflate?: Object|boolean;
/**
* Parameters of the http compression for the polling transports (see zlib).
* Set to false to disable, or set an object with parameter "threshold:number"
* to only compress data if the byte size is above this value (1024) (engine.io)
* @default true|1024
*/
httpCompression?: Object|boolean;
/**
* Name of the HTTP cookie that contains the client sid to send as part of
* handshake response headers. Set to false to not send one (engine.io)
* @default "io"
*/
cookie?: string|boolean;
}
/**
* The Namespace, sandboxed environments for sockets, each connection
* to a Namespace requires a new Socket
*/
interface Namespace extends NodeJS.EventEmitter {
/**
* The name of the NameSpace
*/
name: string;
/**
* The controller Server for this Namespace
*/
server: Server;
/**
* A dictionary of all the Sockets connected to this Namespace, where
* the Socket ID is the key
*/
sockets: { [id: string]: Socket };
/**
* A dictionary of all the Sockets connected to this Namespace, where
* the Socket ID is the key
*/
connected: { [id: string]: Socket };
/**
* The Adapter that we're using to handle dealing with rooms etc
*/
adapter: Adapter;
/**
* Sets the 'json' flag when emitting an event
*/
json: Namespace;
/**
* Registers a middleware function, which is a function that gets executed
* for every incoming Socket
* @param fn The function to call when we get a new incoming socket. It should
* take one parameter of type Socket, and one callback function to call to
* execute the next middleware function. The callback can take one optional
* parameter, err, if there was an error. Errors passed to middleware callbacks
* are sent as special 'error' packets to clients
* @return This Namespace
*/
use( fn: ( socket:Socket, fn: ( err?: any ) => void ) =>void ): Namespace;
/**
* Targets a room when emitting
* @param room The name of the room that we're targeting
* @return This Namespace
*/
to( room: string ): Namespace;
/**
* @see to( room )
*/
in( room: string ): Namespace;
/**
* Sends a 'message' event
* @see emit( event, ...args )
* @return This Namespace
*/
send( ...args: any[] ): Namespace;
/**
* @see send( ...args )
*/
write( ...args: any[] ): Namespace;
/**
* The event fired when we get a new connection
* @param event The event being fired: 'connection'
* @param listener A listener that should take one parameter of type Socket
* @return This Namespace
*/
on( event: 'connection', listener: ( socket: Socket ) => void ): any;
/**
* @see on( 'connection', listener )
*/
on( event: 'connect', listener: ( socket: Socket ) => void ): any;
/**
* Base 'on' method to add a listener for an event
* @param event The event that we want to add a listener for
* @param listener The callback to call when we get the event. The parameters
* for the callback depend on the event
* @ This Namespace
*/
on( event: string, listener: Function ): any;
/**
* Gets a list of clients.
* @return This Namespace
*/
clients( fn: Function ): Namespace;
/**
* Sets the compress flag.
* @param compress If `true`, compresses the sending data
* @return This Namespace
*/
compress( compress: boolean ): Namespace;
}
/**
* The socket, which handles our connection for a namespace. NOTE: while
* we technically extend NodeJS.EventEmitter, we're not putting it here
* as we have a problem with the emit() event (as it's overridden with a
* different return)
*/
interface Socket {
/**
* The namespace that this socket is for
*/
nsp: Namespace;
/**
* The Server that our namespace is in
*/
server: Server;
/**
* The Adapter that we use to handle our rooms
*/
adapter: Adapter;
/**
* The unique ID for this Socket. Regenerated at every connection. This is
* also the name of the room that the Socket automatically joins on connection
*/
id: string;
/**
* The http.IncomingMessage request sent with the connection. Useful
* for recovering headers etc
*/
request: any;
/**
* The Client associated with this Socket
*/
client: Client;
/**
* The underlying Engine.io Socket instance
*/
conn: {
/**
* The ID for this socket - matches Client.id
*/
id: string;
/**
* The Engine.io Server for this socket
*/
server: any;
/**
* The ready state for the client. Either 'opening', 'open', 'closing', or 'closed'
*/
readyState: string;
/**
* The remote IP for this connection
*/
remoteAddress: string;
};
/**
* The list of rooms that this Socket is currently in, where
* the ID the the room ID
*/
rooms: { [id: string]: string };
/**
* Is the Socket currently connected?
*/
connected: boolean;
/**
* Is the Socket currently disconnected?
*/
disconnected: boolean;
/**
* The object used when negociating the handshake
*/
handshake: {
/**
* The headers passed along with the request. e.g. 'host',
* 'connection', 'accept', 'referer', 'cookie'
*/
headers: any;
/**
* The current time, as a string
*/
time: string;
/**
* The remote address of the connection request
*/
address: string;
/**
* Is this a cross-domain request?
*/
xdomain: boolean;
/**
* Is this a secure request?
*/
secure: boolean;
/**
* The timestamp for when this was issued
*/
issued: number;
/**
* The request url
*/
url: string;
/**
* Any query string parameters in the request url
*/
query: any;
};
/**
* Sets the 'json' flag when emitting an event
*/
json: Socket;
/**
* Sets the 'volatile' flag when emitting an event. Volatile messages are
* messages that can be dropped because of network issues and the like. Use
* for high-volume/real-time messages where you don't need to receive *all*
* of them
*/
volatile: Socket;
/**
* Sets the 'broadcast' flag when emitting an event. Broadcasting an event
* will send it to all the other sockets in the namespace except for yourself
*/
broadcast: Socket;
/**
* Emits an event to this client. If the 'broadcast' flag was set, this will
* emit to all other clients, except for this one
* @param event The event that we want to emit
* @param args Any number of optional arguments to pass with the event. If the
* last argument is a function, it will be called as an ack. The ack should
* take whatever data was sent with the packet
* @return This Socket
*/
emit( event: string, ...args: any[]): Socket;
/**
* Targets a room when broadcasting
* @param room The name of the room that we're targeting
* @return This Socket
*/
to( room: string ): Socket;
/**
* @see to( room )
*/
in( room: string ): Socket;
/**
* Sends a 'message' event
* @see emit( event, ...args )
*/
send( ...args: any[] ): Socket;
/**
* @see send( ...args )
*/
write( ...args: any[] ): Socket;
/**
* Joins a room. You can join multiple rooms, and by default, on connection,
* you join a room with the same name as your ID
* @param name The name of the room that we want to join
* @param fn An optional callback to call when we've joined the room. It should
* take an optional parameter, err, of a possible error
* @return This Socket
*/
join( name: string, fn?: ( err?: any ) => void ): Socket;
/**
* Leaves a room
* @param name The name of the room to leave
* @param fn An optional callback to call when we've left the room. It should
* take on optional parameter, err, of a possible error
*/
leave( name: string, fn?: Function ): Socket;
/**
* Leaves all the rooms that we've joined
*/
leaveAll(): void;
/**
* Disconnects this Socket
* @param close If true, also closes the underlying connection
* @return This Socket
*/
disconnect( close?: boolean ): Socket;
/**
* Adds a listener for a particular event. Calling multiple times will add
* multiple listeners
* @param event The event that we're listening for
* @param fn The function to call when we get the event. Parameters depend on the
* event in question
* @return This Socket
*/
on( event: string, fn: Function ): Socket;
/**
* @see on( event, fn )
*/
addListener( event: string, fn: Function ): Socket;
/**
* Adds a listener for a particular event that will be invoked
* a single time before being automatically removed
* @param event The event that we're listening for
* @param fn The function to call when we get the event. Parameters depend on
* the event in question
* @return This Socket
*/
once( event: string, fn: Function ): Socket;
/**
* Removes a listener for a particular type of event. This will either
* remove a specific listener, or all listeners for this type of event
* @param event The event that we want to remove the listener of
* @param fn The function to remove, or null if we want to remove all functions
* @return This Socket
*/
removeListener( event: string, fn?: Function ): Socket;
/**
* Removes all event listeners on this object
* @return This Socket
*/
removeAllListeners( event?: string ): Socket;
/**
* Sets the maximum number of listeners this instance can have
* @param n The max number of listeners we can add to this emitter
* @return This Socket
*/
setMaxListeners( n: number ): Socket;
/**
* Returns all the callbacks for a particular event
* @param event The event that we're looking for the callbacks of
* @return An array of callback Functions, or an empty array if we don't have any
*/
listeners( event: string ):Function[];
/**
* Sets the compress flag
* @param compress If `true`, compresses the sending data
* @return This Socket
*/
compress( compress: boolean ): Socket;
}
/**
* The interface used when dealing with rooms etc
*/
interface Adapter extends NodeJS.EventEmitter {
/**
* The namespace that this adapter is for
*/
nsp: Namespace;
/**
* A dictionary of all the rooms that we have in this namespace
* The rooms are made of a `sockets` key which is the dictionary of sockets per ID
*/
rooms: {[room: string]: {sockets: {[id: string]: boolean }}};
/**
* A dictionary of all the socket ids that we're dealing with, and all
* the rooms that the socket is currently in
*/
sids: {[id: string]: {[room: string]: boolean}};
/**
* Adds a socket to a room. If the room doesn't exist, it's created
* @param id The ID of the socket to add
* @param room The name of the room to add the socket to
* @param callback An optional callback to call when the socket has been
* added. It should take an optional parameter, error, if there was a problem
*/
add( id: string, room: string, callback?: ( err?: any ) => void ): void;
/**
* Removes a socket from a room. If there are no more sockets in the room,
* the room is deleted
* @param id The ID of the socket that we're removing
* @param room The name of the room to remove the socket from
* @param callback An optional callback to call when the socket has been
* removed. It should take on optional parameter, error, if there was a problem
*/
del( id: string, room: string, callback?: ( err?: any ) => void ): void;
/**
* Removes a socket from all the rooms that it's joined
* @param id The ID of the socket that we're removing
*/
delAll( id: string ):void;
/**
* Broadcasts a packet
* @param packet The packet to broadcast
* @param opts Any options to send along:
* - rooms: An optional list of rooms to broadcast to. If empty, the packet is broadcast to all sockets
* - except: A list of Socket IDs to exclude
* - flags: Any flags that we want to send along ('json', 'volatile', 'broadcast')
*/
broadcast( packet: any, opts: { rooms?: string[]; except?: string[]; flags?: {[flag: string]: boolean} } ):void;
}
/**
* The client behind each socket (can have multiple sockets)
*/
interface Client {
/**
* The Server that this client belongs to
*/
server: Server;
/**
* The underlying Engine.io Socket instance
*/
conn: {
/**
* The ID for this socket - matches Client.id
*/
id: string;
/**
* The Engine.io Server for this socket
*/
server: any;
/**
* The ready state for the client. Either 'opening', 'open', 'closing', or 'closed'
*/
readyState: string;
/**
* The remote IP for this connection
*/
remoteAddress: string;
};
/**
* The ID for this client. Regenerated at every connection
*/
id: string;
/**
* The http.IncomingMessage request sent with the connection. Useful
* for recovering headers etc
*/
request: any;
/**
* The dictionary of sockets currently connect via this client (i.e. to different
* namespaces) where the Socket ID is the key
*/
sockets: {[id: string]: Socket};
/**
* A dictionary of all the namespaces for this client, with the Socket that
* deals with that namespace
*/
nsps: {[nsp: string]: Socket};
}
}

10
typings/tsd.d.ts vendored Normal file
View File

@@ -0,0 +1,10 @@
/// <reference path="bunyan/bunyan.d.ts" />
/// <reference path="express/express.d.ts" />
/// <reference path="mime/mime.d.ts" />
/// <reference path="node/node.d.ts" />
/// <reference path="serve-static/serve-static.d.ts" />
/// <reference path="socket.io/socket.io.d.ts" />
/// <reference path="underscore/underscore.d.ts" />
/// <reference path="onoff/onoff.d.ts" />
/// <reference path="form-data/form-data.d.ts" />
/// <reference path="request/request.d.ts" />

3629
typings/underscore/underscore.d.ts vendored Normal file
View File

File diff suppressed because it is too large Load Diff