@eleven-am/pondsocket 0.1.0

package/pondSocket/pondResponse.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointResponse = exports.PondChannelResponse = exports.ChannelResponse = exports.PondResponse = void 0;
+const enums_1 = require("./enums");
+class PondResponse {
+}
+exports.PondResponse = PondResponse;
+class ChannelResponse extends PondResponse {
+    constructor(clientId, channel, resolver) {
+        super();
+        this._clientId = clientId;
+        this._channel = channel;
+        this._resolver = resolver;
+        this._hasExecuted = false;
+    }
+    get hasExecuted() {
+        return this._hasExecuted;
+    }
+    accept(assigns) {
+        if (this._hasExecuted)
+            throw new Error('Response has already been sent');
+        this._hasExecuted = true;
+        if (assigns) {
+            if (Object.values(enums_1.PondSenders).includes(this._clientId))
+                throw new Error('Cannot accept a message sent by the server');
+            this._channel.updateUser(this._clientId, assigns.presence || {}, assigns.assigns || {});
+            this._channel.data = assigns.channelData || {};
+        }
+        this._resolver(false);
+    }
+    reject(message, errorCode) {
+        if (this._hasExecuted)
+            throw new Error('Response has already been sent');
+        this._hasExecuted = true;
+        message = message || 'Message rejected';
+        errorCode = errorCode || 403;
+        if (Object.values(enums_1.PondSenders).includes(this._clientId))
+            throw new Error('Cannot reject a message sent by the server');
+        this._channel.respondToClient('error', { message: message, code: errorCode }, this._clientId, enums_1.ServerActions.ERROR);
+        this._resolver(true);
+    }
+    send(event, payload, assigns) {
+        if (this._hasExecuted)
+            throw new Error('Response has already been sent');
+        this._hasExecuted = true;
+        if (Object.values(enums_1.PondSenders).includes(this._clientId))
+            throw new Error('Cannot reply to a message sent by the server');
+        if (assigns) {
+            this._channel.updateUser(this._clientId, assigns.presence || {}, assigns.assigns || {});
+            this._channel.data = assigns.channelData || {};
+        }
+        this._channel.respondToClient(event, payload, this._clientId);
+        this._resolver(false);
+    }
+}
+exports.ChannelResponse = ChannelResponse;
+class PondChannelResponse extends PondResponse {
+    constructor(user, handler) {
+        super();
+        this._handler = handler;
+        this._user = user;
+        this._executed = false;
+    }
+    get isResolved() {
+        return this._executed;
+    }
+    accept(assigns) {
+        if (this._executed)
+            throw new Error('Response has already been sent');
+        this._executed = true;
+        const newAssigns = this._mergeAssigns(assigns);
+        this._handler(newAssigns);
+    }
+    reject(message, errorCode) {
+        if (this._executed)
+            throw new Error('Response has already been sent');
+        this._executed = true;
+        const newMessage = {
+            action: enums_1.ServerActions.ERROR,
+            event: "JOIN_REQUEST_ERROR",
+            channelName: enums_1.PondSenders.POND_CHANNEL,
+            payload: {
+                message: message || 'Unauthorized join request',
+                code: errorCode || 403,
+            }
+        };
+        this._user.socket.send(JSON.stringify(newMessage));
+    }
+    send(event, payload, assigns) {
+        if (this._executed)
+            throw new Error('Response has already been sent');
+        this._executed = true;
+        const newAssigns = this._mergeAssigns(assigns);
+        this._handler(newAssigns, { event: event, payload: payload });
+    }
+    _mergeAssigns(assigns) {
+        return {
+            presence: (assigns === null || assigns === void 0 ? void 0 : assigns.presence) || {},
+            channelData: (assigns === null || assigns === void 0 ? void 0 : assigns.channelData) || {},
+            assigns: Object.assign({}, this._user.assigns, (assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}),
+        };
+    }
+}
+exports.PondChannelResponse = PondChannelResponse;
+class EndpointResponse extends PondResponse {
+    constructor(handler) {
+        super();
+        this._handler = handler;
+    }
+    accept(assigns) {
+        this._handler((assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}, {});
+    }
+    reject(message, errorCode) {
+        this._handler({}, { error: { message: message || 'Message rejected', code: errorCode || 403 } });
+    }
+    send(event, payload, assigns) {
+        this._handler((assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}, { message: { event: event, payload: payload } });
+    }
+}
+exports.EndpointResponse = EndpointResponse;

package/pondSocket/pondSocket.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import {IncomingMessage, Server as HTTPServer} from "http";
+import {WebSocketServer} from "ws";
+import {BaseClass, PondPath} from "../pondBase";
+import {Endpoint, EndpointHandler} from "./endpoint";
+import internal from "stream";
+import {NextFunction} from "./socketMiddleWare";
+
+export declare class PondSocket extends BaseClass {
+
+    constructor(server?: HTTPServer, socketServer?: WebSocketServer);
+
+    /**
+     * @desc Specifies the port to listen on
+     * @param port - the port to listen on
+     * @param callback - the callback to call when the server is listening
+     */
+    listen(port: number, callback: (port?: number) => void): HTTPServer<typeof IncomingMessage, typeof import("http").ServerResponse>;
+
+    /**
+     * @desc adds a middleware to the server
+     * @param middleware - the middleware to add
+     */
+    useOnUpgrade(middleware: (req: IncomingMessage, socket: internal.Duplex, head: Buffer, next: NextFunction) => void): void;
+
+    /**
+     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
+     * @param path - the pattern to accept || can also be a regex
+     * @param handler - the handler function to authenticate the socket
+     *
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const { query } = parse(req.url || '');
+     *    const { token } = query;
+     *    if (!token)
+     *       return res.reject("No token provided");
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
+     */
+    createEndpoint(path: PondPath, handler: EndpointHandler): Endpoint;
+}

package/pondSocket/pondSocket.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondSocket = void 0;
+const http_1 = require("http");
+const ws_1 = require("ws");
+const pondBase_1 = require("../pondBase");
+const endpoint_1 = require("./endpoint");
+const socketMiddleWare_1 = require("./socketMiddleWare");
+class PondSocket extends pondBase_1.BaseClass {
+    constructor(server, socketServer) {
+        super();
+        this._server = server || new http_1.Server();
+        this._socketServer = socketServer || new ws_1.WebSocketServer({ noServer: true });
+        this._socketChain = new socketMiddleWare_1.SocketMiddleWare(this._server);
+        this._init();
+    }
+    /**
+     * @desc Specifies the port to listen on
+     * @param port - the port to listen on
+     * @param callback - the callback to call when the server is listening
+     */
+    listen(port, callback) {
+        return this._server.listen(port, callback);
+    }
+    /**
+     * @desc adds a middleware to the server
+     * @param middleware - the middleware to add
+     */
+    useOnUpgrade(middleware) {
+        this._socketChain.use(middleware);
+    }
+    /**
+     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
+     * @param path - the pattern to accept || can also be a regex
+     * @param handler - the handler function to authenticate the socket
+     *
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const { query } = parse(req.url || '');
+     *    const { token } = query;
+     *    if (!token)
+     *       return res.reject("No token provided");
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
+     */
+    createEndpoint(path, handler) {
+        const endpoint = new endpoint_1.Endpoint(this._socketServer, handler);
+        this._socketChain.use((req, socket, head, next) => {
+            const address = req.url || "";
+            const dataEndpoint = this.generateEventRequest(path, address);
+            if (!dataEndpoint)
+                return next();
+            endpoint.authoriseConnection(req, socket, head, dataEndpoint);
+        });
+        return endpoint;
+    }
+    /**
+     * @desc Makes sure that every client is still connected to the pond
+     * @param server - WebSocket server
+     */
+    _pingClients(server) {
+        server.on("connection", (ws) => {
+            ws.isAlive = true;
+            ws.on("pong", () => {
+                ws.isAlive = true;
+            });
+        });
+        const interval = setInterval(() => {
+            server.clients.forEach((ws) => {
+                if (ws.isAlive === false)
+                    return ws.terminate();
+                ws.isAlive = false;
+                ws.ping();
+            });
+        }, 30 * 1000);
+        server.on("close", () => clearInterval(interval));
+    }
+    /**
+     * @desc Initializes the server
+     */
+    _init() {
+        this._server.on("error", (error) => {
+            throw new Error(error.message);
+        });
+        this._server.on("listening", () => {
+            this._pingClients(this._socketServer);
+        });
+    }
+}
+exports.PondSocket = PondSocket;

package/pondSocket/server.test.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const endpoint_1 = require("./endpoint");
+const pondSocket_1 = require("./pondSocket");
+const superwstest_1 = __importDefault(require("superwstest"));
+const enums_1 = require("./enums");
+const http_1 = require("http");
+const ws_1 = require("ws");
+describe('server', () => {
+    it('should be defined', () => {
+        expect(pondSocket_1.PondSocket).toBeDefined();
+    });
+    it('should be instantiable', () => {
+        expect(new pondSocket_1.PondSocket()).toBeInstanceOf(pondSocket_1.PondSocket);
+    });
+    it('should ba able to create its own server and websocket server if none is provided', () => {
+        const socket = new pondSocket_1.PondSocket();
+        expect(socket['_server']).toBeDefined();
+        expect(socket['_socketServer']).toBeDefined();
+    });
+    it('should take a server and websocket server if provided', () => {
+        const server = (0, http_1.createServer)();
+        const socketServer = new ws_1.Server({ noServer: true });
+        const socket = new pondSocket_1.PondSocket(server, socketServer);
+        expect(socket['_server']).toBe(server);
+        expect(socket['_socketServer']).toBe(socketServer);
+    });
+    it('should be able to listen on a port', () => {
+        const socket = new pondSocket_1.PondSocket();
+        expect(socket.listen(3001, () => {
+            console.log('socket');
+        })).toBeDefined();
+        socket['_server'].close();
+    });
+    it('should be able to create an endpoint', () => {
+        const socket = new pondSocket_1.PondSocket();
+        const endpoint = socket.createEndpoint('/api/socket', () => {
+            console.log('socket');
+        });
+        expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
+        expect(endpoint['_handler']).toEqual(expect.any(Function));
+    });
+    it('should be able to create multiple endpoints', () => {
+        const server = (0, http_1.createServer)();
+        const socketServer = new ws_1.Server({ noServer: true });
+        const socket = new pondSocket_1.PondSocket(server, socketServer);
+        const endpoint = socket.createEndpoint('/api/socket', () => {
+            console.log('socket');
+        });
+        const endpoint2 = socket.createEndpoint('/api/socket2', () => {
+            console.log('socket2');
+        });
+        expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
+        expect(endpoint['_handler']).toEqual(expect.any(Function));
+        expect(endpoint2).toBeInstanceOf(endpoint_1.Endpoint);
+        expect(endpoint2['_handler']).toEqual(expect.any(Function));
+    });
+    it('should be able to reject a socket', () => {
+        const server = (0, http_1.createServer)();
+        const socketServer = new ws_1.Server({ noServer: true });
+        const socket = new pondSocket_1.PondSocket(server, socketServer);
+        const socketClient = {
+            write: jest.fn(),
+            destroy: jest.fn(),
+        };
+        socket.listen(3001, () => {
+            console.log('server listening');
+        });
+        server.emit('upgrade', {}, socketClient);
+        server.close();
+        // these functions are called because there is no endpoint to accept the socket
+        expect(socketClient.write).toHaveBeenCalled();
+        expect(socketClient.destroy).toHaveBeenCalled();
+    });
+    it('should be able to accept a socket if a handler is provided', async () => {
+        const socket = new pondSocket_1.PondSocket();
+        const server = socket.listen(3001, () => {
+            console.log('server listening');
+        });
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/hello', () => {
+            console.log('server listening');
+        });
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.accept();
+        });
+        await (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade(res => expect(res.statusCode).toBe(101))
+            .close()
+            .expectClosed();
+        server.close();
+    });
+    it('should be able to reject a socket if the handler rejects', async () => {
+        const socket = new pondSocket_1.PondSocket();
+        const server = socket.listen(3001, () => {
+            console.log('server listening');
+        });
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.reject();
+        });
+        await (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectConnectionError();
+        server.close();
+    });
+    it('should be able to send a message after connection', async () => {
+        const socket = new pondSocket_1.PondSocket();
+        const server = socket.listen(3001, () => {
+            console.log('server listening');
+        });
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.send('testEvent', { test: 'test' });
+        });
+        await (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade(res => expect(res.statusCode).toBe(101))
+            .expectJson({
+            action: enums_1.ServerActions.MESSAGE,
+            event: 'testEvent',
+            channelName: 'SERVER',
+            payload: { test: 'test' },
+        })
+            .close()
+            .expectClosed();
+        server.close();
+    });
+});

package/pondSocket/socketMiddleWare.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+
+export declare type NextFunction = () => void;
+

package/pondSocket/socketMiddleWare.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketMiddleWare = void 0;
+class SocketMiddleWare {
+    constructor(server) {
+        this.middleware = [];
+        this._server = server;
+        this._initMiddleware();
+    }
+    use(middleware) {
+        this.middleware.push(middleware);
+    }
+    _execute(req, socket, head) {
+        const temp = this.middleware.concat();
+        const next = () => {
+            const middleware = temp.shift();
+            if (middleware)
+                middleware(req, socket, head, next);
+            else {
+                socket.write('HTTP/1.1 400 Bad Request\r\n\r');
+                socket.destroy();
+            }
+        };
+        next();
+    }
+    _initMiddleware() {
+        this._server.on('upgrade', (req, socket, head) => {
+            this._execute(req, socket, head);
+        });
+    }
+}
+exports.SocketMiddleWare = SocketMiddleWare;

package/pondSocket/types.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import { default_t, ResponsePicker } from "../pondBase";
+import { ClientActions, ServerActions } from "./enums";
+import { WebSocket } from "ws";
+import { IncomingHttpHeaders } from "http";
+export interface NewUser {
+    client: Omit<SocketCache, 'assigns' | 'socket'>;
+    assigns: PondAssigns;
+    presence: PondPresence;
+    channelData: PondChannelData;
+}
+export declare type PondAssigns = default_t;
+export declare type PondPresence = default_t;
+export declare type PondChannelData = default_t;
+export declare type PondMessage = default_t;
+export declare type ServerMessage = {
+    action: ServerActions;
+    channelName: string;
+    payload: default_t;
+    event: string;
+};
+export interface SocketCache {
+    clientId: string;
+    socket: WebSocket;
+    assigns: PondAssigns;
+}
+export interface IncomingConnection {
+    clientId: string;
+    params: default_t<string>;
+    query: default_t<string>;
+    headers: IncomingHttpHeaders;
+    address: string;
+}
+export interface IncomingJoinMessage {
+    clientId: string;
+    channelName: string;
+    clientAssigns: PondAssigns;
+    joinParams: default_t;
+    params: default_t<string>;
+    query: default_t<string>;
+}
+export interface IncomingChannelMessage {
+    channelName: string;
+    event: string;
+    message: default_t;
+    client: {
+        clientId: string;
+        clientAssigns: PondAssigns;
+        clientPresence: PondPresence;
+    };
+    params: default_t<string>;
+    query: default_t<string>;
+}
+export interface PondResponseAssigns {
+    assigns?: PondAssigns;
+    presence?: PondPresence;
+    channelData?: PondChannelData;
+}
+export declare type ClientMessage = {
+    action: ClientActions;
+    channelName: string;
+    event: string;
+    payload: default_t;
+    addresses?: string[];
+};
+export declare type SendResponse<T = ResponsePicker.CHANNEL> = T extends ResponsePicker.CHANNEL ? Required<PondResponseAssigns> : T extends ResponsePicker.POND ? Required<Omit<PondResponseAssigns, 'presence' | 'channelData'>> : never;
+export interface ResponseResolver<T = ResponsePicker.CHANNEL> {
+    assigns: SendResponse<T>;
+    message?: {
+        event: string;
+        payload: PondMessage;
+    };
+    error?: string;
+}

package/pondSocket/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/socket.d.ts

@@ -0,0 +1 @@
+export * from './pondSocket';

package/socket.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pondSocket"), exports);

package/tsconfig.eslint.json

@@ -0,0 +1,5 @@
+{
+  "include": [
+    ".eslintrc.js"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,90 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es2019",
+    /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */
+    "module": "commonjs",
+    /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    // "lib": [],                                   /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
+    // "declaration": true,                         /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    // "rootDir": "./src",                             /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    "downlevelIteration": true,
+    /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,
+    /* Enable all strict type-checking options. */
+    "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
+    "strictNullChecks": true,                    /* Enable strict null checks. */
+    "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
+    "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    "noUnusedLocals": true,                      /* Report errors on unused locals. */
+    "noUnusedParameters": true,                  /* Report errors on unused parameters. */
+    "noImplicitReturns": false,                   /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                  /* Ensure overriding members in derived classes are marked with an 'override' modifier. */
+    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
+
+    /* Module Resolution Options */
+    // "moduleResolution": "node",                  /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,
+    /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,
+    /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true,
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./bin",
+    "declarationDir": "./types",
+    /* Disallow inconsistently-cased references to the same file. */
+    "lib": [
+      "dom",
+      "es5",
+      "scripthost",
+      "es2015.generator"
+    ]
+  },
+  "include": ["src/", ".eslintrc.js", "jest.config.js"],
+  "exclude": ["!src/"]
+}