TypeScript/tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.js

//// [variableDeclaratorResolvedDuringContextualTyping.ts]
module WinJS {
    export interface ValueCallback {
        (value: any): any;
    }

    export interface EventCallback {
        (value: any): void;
    }

    export interface ErrorCallback {
        (error: any): any;
    }

    export interface ProgressCallback {
        (progress: any): any;
    }

    export declare class Promise {
        constructor(init: (complete: ValueCallback, error: ErrorCallback, progress: ProgressCallback) => void, oncancel?: any);

        static as(value: any): Promise;
        static join(promises: { [name: string]: Promise; }): Promise;
        static join(promises: Promise[]): Promise;
        static any(promises: Promise[]): Promise;
        static timeout(delay: number): Promise;
        static wrapError(error: any): Promise;
        static is(value: any): boolean;
        static addEventListener(type: string, fn: EventCallback);

        public then(success?: ValueCallback, error?: ErrorCallback, progress?: ProgressCallback): Promise;
        public done(success?: ValueCallback, error?: ErrorCallback, progress?: ProgressCallback): void;
        public cancel(): void;
    }

    export declare class TPromise<V> {

        constructor(init: (complete: (value: V) => void, error: (err: any) => void, progress: ProgressCallback) => void, oncancel?: any);

        public then<U>(success?: (value: V) => TPromise<U>, error?: (err: any) => TPromise<U>, progress?: ProgressCallback): TPromise<U>;
        public then<U>(success?: (value: V) => TPromise<U>, error?: (err: any) => U, progress?: ProgressCallback): TPromise<U>;
        public then<U>(success?: (value: V) => U, error?: (err: any) => TPromise<U>, progress?: ProgressCallback): TPromise<U>;
        public then<U>(success?: (value: V) => U, error?: (err: any) => U, progress?: ProgressCallback): TPromise<U>;

        public done(success?: (value: V) => void, error?: (err: any) => any, progress?: ProgressCallback): void;
        public cancel(): void;

        public static as<ValueType>(value: ValueType): TPromise<ValueType>;
        public static timeout(delay: number): TPromise<void>;
        public static join<ValueType>(promises: TPromise<ValueType>[]): TPromise<ValueType[]>;
        public static any<ValueType>(promises: TPromise<ValueType>[]): TPromise<ValueType>;
        public static wrapError<ValueType>(error: any): TPromise<ValueType>;
    }

    export interface IXHROptions {
        type?: string;
        url?: string;
        user?: string;
        password?: string;
        responseType?: string;
        headers?: any;
        customRequestInitializer?: (req: any) => void;
        data?: any;
    }
}

module Services {
    export interface IRequestService {
        /**
         * Returns the URL that can be used to access the provided service. The optional second argument can
         * be provided to narrow down the request URL to a specific file system resource. The third argument
         * allows to specify to return a fully absolute server URL. 
         */
        getRequestUrl(service: string, path?: string): string;
        getRequestUrl(service: string, path?: string, absolute?: boolean): string;

        /**
         * Wraps the call into WinJS.XHR to allow for mocking and telemetry. Use this instead
         * of calling WinJS.XHR directly.
         */
        makeRequest(options: WinJS.IXHROptions): WinJS.Promise;
    }
}

module Errors {
    export class ConnectionError /* extends Error */ {
        constructor(request: XMLHttpRequest) {
        }
    }
}

module Files {
    export interface IUploadResult {
        stat: string;
        isNew: boolean;
    }
}

interface XMLHttpRequest {
    status: number;
    responseText: string;
    statusText: string;

}

class FileService {
    private requestService: Services.IRequestService;
    public uploadData(): WinJS.TPromise<Files.IUploadResult> {
        var path = "";
        return this.requestService.makeRequest({
            url: this.requestService.getRequestUrl('root', path),
            type: 'POST',
            headers: {},
            data: "someData"
        }).then((response: XMLHttpRequest) => {
                var result: IUploadResult = { // This should be error
                    stat: this.jsonToStat(newFilePath, "someString"), // _this needs to be emitted to the js file
                    isNew: response.status === 201
                };

                return WinJS.TPromise.as<Files.IUploadResult>(result);
            }, (xhr: XMLHttpRequest) => {
                return WinJS.Promise.wrapError(new Errors.ConnectionError(xhr));
            });
    }
}

//// [variableDeclaratorResolvedDuringContextualTyping.js]
var WinJS;
(function (WinJS) {
})(WinJS || (WinJS = {}));
var Errors;
(function (Errors) {
    var ConnectionError /* extends Error */ = (function () {
        function ConnectionError /* extends Error */(request) {
        }
        return ConnectionError /* extends Error */;
    })();
    Errors.ConnectionError /* extends Error */ = ConnectionError /* extends Error */;
})(Errors || (Errors = {}));
var FileService = (function () {
    function FileService() {
    }
    FileService.prototype.uploadData = function () {
        var _this = this;
        var path = "";
        return this.requestService.makeRequest({
            url: this.requestService.getRequestUrl('root', path),
            type: 'POST',
            headers: {},
            data: "someData"
        }).then(function (response) {
            var result = {
                stat: _this.jsonToStat(newFilePath, "someString"),
                isNew: response.status === 201
            };
            return WinJS.TPromise.as(result);
        }, function (xhr) {
            return WinJS.Promise.wrapError(new Errors.ConnectionError(xhr));
        });
    };
    return FileService;
})();