Added typings.

Author: niemyjski

.gitignore

@@ -2,5 +2,5 @@
 .idea
 node_modules
 public
-typings
+/typings
 /dist/temp

src/services/NodeErrorParser.ts

@@ -48,5 +48,3 @@ export class NodeErrorParser implements IErrorParser {
     return frames;
   }
 }
-
-declare module "stack-trace" {}

src/services/WebErrorParser.ts

@@ -43,64 +43,3 @@ export class WebErrorParser implements IErrorParser {
     return frames;
   }
 }
-
-
-declare module StackTrace {
-  interface StackTraceOptions {
-    filter?: (stackFrame:StackFrame) => boolean;
-    sourceCache?: { URL:string };
-    offline?: boolean;
-  }
-
-  interface StackFrame {
-    constructor(functionName:string, args:any, fileName:string, lineNumber:number, columnNumber:number);
-
-    functionName?:string;
-    args?:any;
-    fileName?:string;
-    lineNumber?:number;
-    columnNumber?:number;
-    toString():string;
-  }
-
-  /**
-   * Get a backtrace from invocation point.
-   * @param options Options Object
-   * @return Array[StackFrame]
-   */
-  function get(options: StackTraceOptions): Promise<StackFrame[]>;
-
-  /**
-   * Given an error object, parse it.
-   * @param error Error object
-   * @param options Object for options
-   * @return Array[StackFrame]
-   */
-  function fromError(error:Error, options?:StackTraceOptions): Promise<StackFrame[]>;
-
-  /**
-   * Use StackGenerator to generate a backtrace.
-   * @param options Object options
-   * @returns Array[StackFrame]
-   */
-  function generateArtificially(options: StackTraceOptions): Promise<StackFrame[]>;
-
-  /**
-   * Given a function, wrap it such that invocations trigger a callback that
-   * is called with a stack trace.
-   *
-   * @param {Function} fn to be instrumented
-   * @param {Function} callback function to call with a stack trace on invocation
-   * @param {Function} errorCallback optional function to call with error if unable to get stack trace.
-   * @param {Object} thisArg optional context object (e.g. window)
-   */
-  function instrument(fn:() => void, callback:(stackFrames:StackFrame[]) => void, errorCallback:() => void, thisArg:any): void;
-
-  /**
-   * Given a function that has been instrumented,
-   * revert the function to it's original (non-instrumented) state.
-   *
-   * @param fn {Function}
-   */
-  function deinstrument(fn:() => void): void;
-}

src/tsconfig.es5.json

@@ -68,6 +68,8 @@
       "files": [
         "../typings/es6-promise/es6-promise.d.ts",
         "../typings/node/node.d.ts",
+        "typings/node-stack-trace/node-stack-trace.d.ts",
+        "typings/stacktrace/stacktrace.d.ts",
         "Exceptionless.ts"
       ]
     }

src/tsconfig.es6.json

@@ -65,6 +65,8 @@
     "exceptionless.es6": {
       "files": [
         "../typings/node/node.d.ts",
+        "typings/node-stack-trace/node-stack-trace.d.ts",
+        "typings/stacktrace/stacktrace.d.ts",
         "Exceptionless.ts"
       ]
     }

src/typings/node-stack-trace/node-stack-trace.d.ts

@@ -0,0 +1,15 @@
+declare module 'stack-trace' {
+  export interface StackFrame {
+    getTypeName():string;
+    getFunctionName():string;
+    getMethodName():string;
+    getFileName():string;
+    getTypeName():string;
+    getLineNumber():number;
+    getColumnNumber():number;
+    isNative():boolean;
+  }
+
+  export function get(belowFn:() => void): StackFrame[];
+  export function parse(err:Error): StackFrame[];
+}

src/typings/stacktrace/stacktrace.d.ts

@@ -0,0 +1,59 @@
+declare module StackTrace {
+  export interface StackTraceOptions {
+    filter?: (stackFrame:StackFrame) => boolean;
+    sourceCache?: { URL:string };
+    offline?: boolean;
+  }
+
+  export interface StackFrame {
+    constructor(functionName:string, args:any, fileName:string, lineNumber:number, columnNumber:number);
+
+    functionName?:string;
+    args?:any;
+    fileName?:string;
+    lineNumber?:number;
+    columnNumber?:number;
+    toString():string;
+  }
+
+  /**
+   * Get a backtrace from invocation point.
+   * @param options Options Object
+   * @return Array[StackFrame]
+   */
+  export function get(options: StackTraceOptions): Promise<StackFrame[]>;
+
+  /**
+   * Given an error object, parse it.
+   * @param error Error object
+   * @param options Object for options
+   * @return Array[StackFrame]
+   */
+  export function fromError(error:Error, options?:StackTraceOptions): Promise<StackFrame[]>;
+
+  /**
+   * Use StackGenerator to generate a backtrace.
+   * @param options Object options
+   * @returns Array[StackFrame]
+   */
+  export function generateArtificially(options: StackTraceOptions): Promise<StackFrame[]>;
+
+  /**
+   * Given a function, wrap it such that invocations trigger a callback that
+   * is called with a stack trace.
+   *
+   * @param {Function} fn to be instrumented
+   * @param {Function} callback function to call with a stack trace on invocation
+   * @param {Function} errorCallback optional function to call with error if unable to get stack trace.
+   * @param {Object} thisArg optional context object (e.g. window)
+   */
+  export function instrument(fn:() => void, callback:(stackFrames:StackFrame[]) => void, errorCallback:() => void, thisArg:any): void;
+
+  /**
+   * Given a function that has been instrumented,
+   * revert the function to it's original (non-instrumented) state.
+   *
+   * @param fn {Function}
+   */
+  export function deinstrument(fn:() => void): void;
+}