TypeScript rsvp.reject函數代碼示例

function testRethrow() {
    RSVP.reject(new Error('all the badness'))
        .catch(RSVP.rethrow)
        .then(value => {
            assertType<void>(value);
        })
        .catch(reason => {
            if (reason instanceof Error) {
                console.log(reason);
            }
        });
}

function testMap() {
    RSVP.map([RSVP.resolve(1), RSVP.resolve(2)], item => item + 1, 'add one').then(results => {
        assertType<number[]>(results);
        assertType<{ length: 2 }>(results);
    });

    RSVP.map([RSVP.resolve('a string'), RSVP.resolve(112233)], String).then(results => {
        assertType<string[]>(results);
        assertType<{ length: 2 }>(results);
    });

    // This is the best we can do: we can't actually write the full type here,
    // which would be `assertType<never>(results)`, but TS can't infer that.
    RSVP.map([RSVP.reject('for any reason')], String).then(results => {
        assertType<{}>(results);
    });
}

function testAllSettled() {
    const resolved1 = RSVP.resolve(1);
    const resolved2 = RSVP.resolve('wat');
    const rejected = RSVP.reject(new Error('oh teh noes'));
    const pending = new RSVP.Promise<{ neato: string }>((resolve, reject) => {
        if ('something') {
            resolve({ neato: 'yay' });
        } else {
            reject('nay');
        }
    });

    // Types flow into resolution properly
    RSVP.allSettled([resolved1, resolved2, rejected, pending]).then(states => {
        assertType<RSVP.PromiseState<number>>(states[0]);
        assertType<RSVP.PromiseState<string>>(states[1]);
        assertType<RSVP.PromiseState<never>>(states[2]);
        assertType<RSVP.PromiseState<{ neato: string }>>(states[3]);
    });

    // Switching on state gives the correctly available items.
    RSVP.allSettled([resolved1, resolved2, rejected, pending]).then(states => {
        states.forEach(element => {
            switch (element.state) {
                case RSVP.State.fulfilled:
                    assertType<RSVP.Resolved<typeof element.value>>(element);
                    break;

                case RSVP.State.rejected:
                    assertType<RSVP.Rejected<typeof element.reason>>(element);
                    break;

                case RSVP.State.pending:
                    assertType<RSVP.Pending>(element);
                    break;

                default:
                    // Someday maybe TS will have exhaustiveness checks.
                    break;
            }
        });
    });
}

function testFilter() {
    RSVP.filter([RSVP.resolve(1), RSVP.resolve(2)], item => item > 1, 'over one').then(results => {
        assertType<number[]>(results);
    });

    RSVP.filter(
        [RSVP.resolve('a string'), RSVP.resolve(112233)],
        item => String(item).length < 10,
        'short string'
    ).then(results => {
        assertType<Array<string | number>>(results);
    });

    // This is the best we can do: we can't actually write the full type here,
    // which would be `assertType<never>(results)`, but TS can't infer that.
    const isString = (item: any): item is string => typeof item === 'string';
    RSVP.filter([RSVP.reject('for any reason')], isString).then(results => {
        assertType<{}>(results);
    });
}

function testAll() {
    const imported = all([]);
    const empty = RSVP.Promise.all([]);

    const everyPromise = RSVP.all([
        'string',
        RSVP.resolve(42),
        RSVP.resolve({ hash: 'with values' }),
    ]);

    assertType<RSVP.Promise<[string, number, { hash: string }]>>(everyPromise);

    const anyFailure = RSVP.all([12, 'strings', RSVP.reject('anywhere')]);
    assertType<RSVP.Promise<{}>>(anyFailure);

    let promise1 = RSVP.resolve(1);
    let promise2 = RSVP.resolve('2');
    let promise3 = RSVP.resolve({ key: 13 });
    RSVP.Promise.all([promise1, promise2, promise3], 'my label').then(function(array) {
        assertType<number>(array[0]);
        assertType<string>(array[1]);
        assertType<{ key: number }>(array[2]);
    });
}

 function keepGoing() {
   return reject('NOPE');
 }

import RSVP from 'rsvp';

let promise1: RSVP.Promise<number, Error> = RSVP.Promise.resolve(1);
let promise1a: RSVP.Promise<number, Error> = RSVP.resolve(1);

let promise2: RSVP.Promise<number, Error> = RSVP.Promise.resolve(2);

let promise3: RSVP.Promise<number, Error> = RSVP.Promise.reject(new Error('3'));
let promise3a: RSVP.Promise<number, Error> = RSVP.reject(new Error('3'));

let promiseArray = [promise1, promise2, promise3];

let promiseHash = {
    promiseA: promise1,
    promiseB: promise2,
    promiseC: promise3,
    notAPromise: 4,
};

RSVP.Promise.all(promiseArray).then(arr => {}, err => {});
RSVP.all(promiseArray).then(arr => {}, err => {});

RSVP.Promise.race(promiseArray).then(arr => {}, err => {});
RSVP.race(promiseArray).then(arr => {}, err => {});

RSVP.allSettled(promiseArray).then(arr => {}, err => {});

let deferred = RSVP.defer();
deferred.resolve('Success');
deferred.promise.then(value => {});