Move all packages to a types directory

types/angular-websocket/angular-websocket-tests.ts

@@ -0,0 +1,69 @@
+let dummySocket: ng.websocket.IWebSocket;
+let dummyPromise: ng.IPromise<void>;
+let dummyScope: ng.IScope;
+
+let provider: ng.websocket.IWebSocketProvider = (url: string, protocols?:string[] | ng.websocket.IWebSocketConfigOptions, options?: ng.websocket.IWebSocketConfigOptions) => {
+    return dummySocket;
+}
+
+let socketWithProtocol = provider("wss://localhost", "protocol");
+let socketWithProtocols = provider("wss://localhost", ["protocol-a", "protocol-b"]);
+
+let socketWithOptions = provider("wss://localhost", {
+  scope: dummyScope,
+  rootScopeFailOver: true,
+  useApplyAsync: true,
+  initialTimeout: 100,
+  maxTimeout: 300000,
+  reconnectIfNotNormalClose: true,
+  binaryType: "blob"
+});
+
+let socketWithProtocolAndOptions = provider("wss://localhost", "protocol", {
+  scope: dummyScope,
+  rootScopeFailOver: true,
+  useApplyAsync: true,
+  initialTimeout: 100,
+  maxTimeout: 300000,
+  reconnectIfNotNormalClose: true,
+  binaryType: "blob"
+});
+
+let socket = provider("wss://localhost");
+
+socket.onOpen((event) => {})
+      .onClose((event) => {})
+      .onError((event) => {})
+      .onMessage((event) => {});
+
+socket.onMessage((event) => {}, { filter: /Some Filter/ })
+      .onMessage((event) => {}, { filter: 'Some Filter' })
+      .onMessage((event) => {}, { filter: 'Some Filter', autoApply: true })
+      .onMessage((event) => {}, { autoApply: false });
+
+socket.close(true);
+socket.close();
+
+socket.send("Some great data here!").finally(() => {});
+socket.send({ list: [1, 2, 3, 4] });
+
+socket.socket.send("data");
+socket.socket.close();
+socket.socket.close(1);
+socket.socket.close(1, "reason");
+
+socket.sendQueue.push({ message: "msg", defered: dummyPromise });
+
+socket.onOpenCallbacks.push((event: Event) => {});
+socket.onCloseCallbacks.push((event: CloseEvent) => {});
+socket.onErrorCallbacks.push((event: Event) => {});
+socket.onMessageCallbacks.push({ fn: (event: MessageEvent) => {}, pattern: 'Some Filter', autoApply: true });
+socket.onMessageCallbacks.push({ fn: (event: MessageEvent) => {}, pattern: /Some Filter/, autoApply: true });
+socket.onMessageCallbacks.push({ fn: (event: MessageEvent) => {}, pattern: undefined, autoApply: true });
+
+socket.readyState = 0;
+
+socket.initialTimeout = 10;
+
+socket.maxTimeout = 5000;
+

types/angular-websocket/index.d.ts

@@ -0,0 +1,159 @@
+// Type definitions for angular-websocket v2.0
+// Project: https://github.com/AngularClass/angular-websocket
+// Definitions by: Nick Veys <https://github.com/nickveys>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import * as ng from "angular";
+
+declare module "angular" {
+    namespace websocket {
+
+        /**
+         * Options available to be specified for IWebSocketProvider.
+         */
+        type IWebSocketConfigOptions = {
+        scope?: ng.IScope;
+        rootScopeFailOver?: boolean;
+        useApplyAsync?: boolean;
+        initialTimeout?: number;
+        maxTimeout?: number;
+        binaryType?: "blob" | "arraybuffer";
+        reconnectIfNotNormalClose?: boolean;
+        }
+        interface IWebSocketProvider {
+            /**
+             * Creates and opens an IWebSocket instance.
+             *
+             * @param url url to connect to
+             * @return websocket instance
+             */
+            (url: string, protocols?: string | string[] | IWebSocketConfigOptions, options?: IWebSocketConfigOptions): IWebSocket;
+        }
+
+        /** Options available to be specified for IWebSocket.onMessage */
+        type IWebSocketMessageOptions = {
+
+            /**
+             * If specified, only messages that match the filter will cause the message event
+             * to be fired.
+             */
+            filter?: string | RegExp;
+
+            /** If true, each message handled will safely call `$rootScope.$digest()`. */
+            autoApply?: boolean;
+        }
+
+        /** Type corresponding to onMessage callbaks stored in $Websocket#onMessageCallbacks instance. */
+        type IWebSocketMessageHandler = {
+        fn: (evt: MessageEvent) => void;
+        pattern: string | RegExp;
+        autoApply: boolean;
+        }
+
+        /** Type corresponding to items stored in $WebSocket#sendQueue instance. */
+        type IWebSocketQueueItem = {
+        message: any;
+        defered: ng.IPromise<void>;
+        }
+
+        interface IWebSocket {
+
+            /**
+             * Adds a callback to be executed each time a socket connection is opened for
+             * this instance.
+             *
+             * @param event event object
+             * @returns this instance, for method chaining
+             */
+            onOpen(callback: (event: Event) => void): IWebSocket;
+
+            /**
+             * Adds a callback to be executed each time a socket connection is closed for
+             * this instance.
+             *
+             * @param event event object
+             * @returns this instance, for method chaining
+             */
+            onClose(callback: (event: CloseEvent) => void): IWebSocket;
+
+            /**
+             * Adds a callback to be executed each time a socket connection is closed for
+             * this instance.
+             *
+             * @param event event object
+             * @returns this instance, for method chaining
+             */
+            onError(callback: (event: Event) => void): IWebSocket;
+
+            /**
+             * Adds a callback to be executed each time a socket connection has an error for
+             * this instance.
+             *
+             * @param event event object
+             * @returns this instance, for method chaining
+             */
+            onMessage(callback: (event: MessageEvent) => void, options?: IWebSocketMessageOptions): IWebSocket;
+
+            /**
+             * Closes the underlying socket, as long as no data is still being sent from the client.
+             *
+             * @param force if `true`, force close even if data is still being sent
+             * @returns this instance, for method chaining
+             */
+            close(force?: boolean): IWebSocket;
+
+            /**
+             * Adds data to a queue, and attempts to send if the socket is ready.
+             *
+             * @param data data to send, if this is an object, it will be stringified before sending
+             */
+            send(data: string | {}): ng.IPromise<any>;
+
+            /**
+             * WebSocket instance.
+             */
+            socket: WebSocket;
+
+            /**
+             * Queue of send calls to be made on socket when socket is able to receive data.
+             */
+            sendQueue: IWebSocketQueueItem[];
+
+            /**
+             * List of callbacks to be executed when the socket is opened.
+             */
+            onOpenCallbacks: ((evt: Event) => void)[];
+
+            /**
+             * List of callbacks to be executed when a message is received from the socket.
+             */
+            onMessageCallbacks: IWebSocketMessageHandler[];
+
+            /**
+             * List of callbacks to be executed when an error is received from the socket.
+             */
+            onErrorCallbacks: ((evt: Event) => void)[];
+
+            /**
+             * List of callbacks to be executed when the socket is closed.
+             */
+            onCloseCallbacks: ((evt: CloseEvent) => void)[];
+
+            /**
+             * Returns either the readyState value from the underlying WebSocket instance
+             * or a proprietary value representing the internal state
+             */
+            readyState: number;
+
+            /**
+             * The initial timeout.
+             */
+            initialTimeout: number;
+
+            /**
+             * Maximun timeout used to determine reconnection delay.
+             */
+            maxTimeout: number;
+        }
+    }
+}

types/angular-websocket/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "files": [
+        "index.d.ts",
+        "angular-websocket-tests.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    }
+}