163 lines
5.8 KiB
TypeScript
163 lines
5.8 KiB
TypeScript
//// [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;
|
|
})();
|