Merge pull request DefinitelyTyped#4339 from niemyjski/master

Added stacktrace.js and node-stack-trace definitions.

Author: vvakame

stack-trace/stack-trace-tests.ts

@@ -0,0 +1,8 @@
+import stackTrace = require('stack-trace');
+
+var currentStackTrace = stackTrace.get();
+
+var err = new Error('something went wrong');
+var trace = stackTrace.parse(err);
+
+var fileName = trace[0].getFileName();

stack-trace/stack-trace.d.ts

@@ -0,0 +1,20 @@
+// Type definitions for node-stack-trace
+// Project: https://github.com/felixge/node-stack-trace
+// Definitions by: Exceptionless <https://github.com/exceptionless>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+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[];
+}

stacktrace-js/stacktrace-js-tests.ts

@@ -0,0 +1,24 @@
+/// <reference path="stacktrace-js.d.ts" />
+
+function interestingFn() {
+    return 'https://github.com/exceptionless/Exceptionless';
+}
+
+var callback = function(stackframes:StackTrace.StackFrame[]) {
+    var stringifiedStack = stackframes.map(function(sf:StackTrace.StackFrame) {
+        return sf.toString();
+    }).join('\n');
+    console.log(stringifiedStack);
+};
+
+var errorCallback = function(err:Error) { console.log(err.message); };
+
+StackTrace.get();
+
+// Somewhere else...
+var error = new Error('BOOM!');
+StackTrace.fromError(error);
+StackTrace.generateArtificially();
+
+StackTrace.instrument(interestingFn, callback, errorCallback);
+StackTrace.deinstrument(interestingFn);

stacktrace-js/stacktrace-js.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for stacktrace.js
+// Project: https://github.com/stacktracejs/stacktrace.js
+// Definitions by: Exceptionless <https://github.com/exceptionless>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../es6-promise/es6-promise.d.ts"/>
+
+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): StackFrame;
+
+    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:(error:Error) => 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;
+}