status-im/react-native
2
0
Fork 0
mirror of https://github.com/status-im/react-native.git synced 2025-01-24 16:29:01 +00:00
Code Issues Projects Releases Wiki Activity

Replace ES6Promise with Promise

Browse Source
This commit is contained in:
Forbes Lindesay 2015-04-15 06:04:42 -07:00
parent 7a68691686
commit 4f8b2825a0
3 changed files with 37 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
Libraries/Promise.js Normal file
View File

@ -0,0 +1,37 @@
/**
*
* Copyright 2013-2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @providesModule Promise
*
* This module wraps and augments the minimally ES6-compliant Promise
* implementation provided by the promise npm package.
*/
'use strict';
global.setImmediate = require('setImmediate');
var Promise = require('promise/setimmediate/es6-extensions');
require('promise/setimmediate/done');
/**
* Handle either fulfillment or rejection with the same callback.
*/
Promise.prototype.finally = function(onSettled) {
return this.then(onSettled, onSettled);
};
module.exports = Promise;

364
Libraries/vendor/core/ES6Promise.js vendored
View File

@ -1,364 +0,0 @@
/**
* @generated SignedSource<<d169e3bbcd91c2e26877882e0d02f289>>
*
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !! This file is a check-in of a static_upstream project! !!
* !! !!
* !! You should not modify this file directly. Instead: !!
* !! 1) Use `fjs use-upstream` to temporarily replace this with !!
* !! the latest version from upstream. !!
* !! 2) Make your changes, test them, etc. !!
* !! 3) Use `fjs push-upstream` to copy your changes back to !!
* !! static_upstream. !!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*
* Copyright 2013-2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @providesModule ES6Promise
*
* This module implements the minimum functionality necessary to comply
* with chapter 25.4 of the ES6 specification. Any extensions to Promise
* or Promise.prototype should be added in the Promise module.
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise-objects
*/
module.exports = (function(global, undefined) {
'use strict';
var setImmediate = require('setImmediate');
// These are the possible values for slots(promise).state.
var PENDING_STATE = 'pending';
var FULFILLED_STATE = 'fulfilled';
var REJECTED_STATE = 'rejected';
// The ES6 specification makes heavy use of a notion of internal slots.
// Some of these slots are best implemented as closure variables, such
// as the alreadySettled variable in createResolvingFunctions, which
// corresponds to the resolve.[[AlreadyResolved]].value property in the
// specification. Other slots are best implemented as properties of a
// slots object attached to the host object by a pseudo-private
// property. The latter kind of slots may be accessed by passing the
// host object (such as a Promise or a resolve/reject function object)
// to the slots function; e.g., the slots(promise).state slot, which
// corresponds to promise.[[PromiseState]] in the specification.
var slotsKey = '__slots$' + Math.random().toString(36).slice(2);
function slots(obj) {
var result = obj[slotsKey];
if (!result) {
// In ES5+ environments, this property will be safely non-writable,
// non-configurable, and non-enumerable. This implementation does
// not logically rely on those niceties, however, so this code works
// just fine in pre-ES5 environments, too.
obj[slotsKey] = result = {};
if (Object.defineProperty) try {
Object.defineProperty(obj, slotsKey, { value: result });
} catch (definePropertyIsBrokenInIE8) {}
}
return result;
}
// Reusable callback functions. The identify function is the default
// when onFulfilled is undefined or null, and the raise function is the
// default when onRejected is undefined or null.
function identity(x) { return x; }
function raise(x) { throw x; }
/**
* When the Promise function is called with argument executor, the
* following steps are taken:
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise
*
* The executor argument must be a function object. It is called for
* initiating and reporting completion of the possibly deferred action
* represented by this Promise object. The executor is called with two
* arguments: resolve and reject. These are functions that may be used
* by the executor function to report eventual completion or failure of
* the deferred computation. Returning from the executor function does
* not mean that the deferred action has been completed, but only that
* the request to eventually perform the deferred action has been
* accepted.
*
* The resolve function that is passed to an executor function accepts a
* single argument. The executor code may eventually call the resolve
* function to indicate that it wishes to resolve the associated Promise
* object. The argument passed to the resolve function represents the
* eventual value of the deferred action and can be either the actual
* fulfillment value or another Promise object which will provide the
* value if it is fullfilled.
*
* The reject function that is passed to an executor function accepts a
* single argument. The executor code may eventually call the reject
* function to indicate that the associated Promise is rejected and will
* never be fulfilled. The argument passed to the reject function is
* used as the rejection value of the promise. Typically it will be an
* Error object.
*
* When Promise is called as a function rather than as a constructor, it
* initializes its this value with the internal state necessary to
* support the Promise.prototype methods.
*
* The Promise constructor is designed to be subclassable. It may be
* used as the value in an extends clause of a class
* definition. Subclass constructors that intend to inherit the
* specified Promise behaviour must include a super call to Promise,
* e.g. by invoking Promise.call(this, executor).
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise-constructor
*/
function Promise(executor) {
var promiseSlots = slots(this);
promiseSlots.state = PENDING_STATE;
promiseSlots.fulfillReactions = [];
promiseSlots.rejectReactions = [];
var resolvingFunctions = createResolvingFunctions(this);
var reject = resolvingFunctions.reject;
try {
executor(resolvingFunctions.resolve, reject);
} catch (err) {
reject(err);
}
}
function createResolvingFunctions(promise) {
var alreadySettled = false;
return {
resolve: function(resolution) {
if (!alreadySettled) {
alreadySettled = true;
if (resolution === promise) {
return settlePromise(
promise,
REJECTED_STATE,
new TypeError('Cannot resolve promise with itself')
);
}
// To be treated as a Promise-like object, the resolution only
// needs to be an object with a callable .then method.
if (!resolution ||
typeof resolution !== "object" ||
typeof resolution.then !== "function") {
return settlePromise(promise, FULFILLED_STATE, resolution);
}
var resolvingFunctions = createResolvingFunctions(promise);
var reject = resolvingFunctions.reject;
try {
resolution.then(resolvingFunctions.resolve, reject);
} catch (err) {
reject(err);
}
}
},
reject: function(reason) {
if (!alreadySettled) {
alreadySettled = true;
settlePromise(promise, REJECTED_STATE, reason);
}
}
};
}
// This function unifies the FulfillPromise and RejectPromise functions
// defined in the ES6 specification.
function settlePromise(promise, state, result) {
var promiseSlots = slots(promise);
if (promiseSlots.state !== PENDING_STATE) {
throw new Error('Settling a ' + promiseSlots.state + ' promise');
}
var reactions;
if (state === FULFILLED_STATE) {
reactions = promiseSlots.fulfillReactions;
} else if (state === REJECTED_STATE) {
reactions = promiseSlots.rejectReactions;
}
promiseSlots.result = result;
promiseSlots.fulfillReactions = undefined;
promiseSlots.rejectReactions = undefined;
promiseSlots.state = state;
var count = reactions.length;
count && setImmediate(function() {
for (var i = 0; i < count; ++i) {
reactions[i](promiseSlots.result);
}
});
}
/**
* The Promise.all function returns a new promise which is fulfilled
* with an array of fulfillment values for the passed promises, or
* rejects with the reason of the first passed promise that rejects. It
* resoves all elements of the passed iterable to promises as it runs
* this algorithm.
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise.all
*/
Promise.all = function(array) {
var Promise = this;
return new Promise(function(resolve, reject) {
var results = [];
var remaining = 0;
array.forEach(function(element, index) {
++remaining; // Array might be sparse.
Promise.resolve(element).then(function(result) {
if (!results.hasOwnProperty(index)) {
results[index] = result;
--remaining || resolve(results);
}
}, reject);
});
remaining || resolve(results);
});
};
/**
* The Promise.race function returns a new promise which is settled in
* the same way as the first passed promise to settle. It resolves all
* elements of the passed iterable to promises as it runs this
* algorithm.
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise.race
*/
Promise.race = function(array) {
var Promise = this;
return new Promise(function(resolve, reject) {
array.forEach(function(element) {
Promise.resolve(element).then(resolve, reject);
});
});
};
/**
* The Promise.resolve function returns either a new promise resolved
* with the passed argument, or the argument itself if the argument a
* promise produced by this construtor.
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise.resolve
*/
Promise.resolve = function(x) {
return x instanceof Promise && x.constructor === this
? x // Refuse to create promises for promises.
: new this(function(resolve) { resolve(x); });
};
/**
* The Promise.reject function returns a new promise rejected with the
* passed argument.
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise.reject
*/
Promise.reject = function(r) {
return new this(function(_, reject) { reject(r); });
};
var Pp = Promise.prototype;
/**
* When the .then method is called with arguments onFulfilled and
* onRejected, the following steps are taken:
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise.prototype.then
*/
Pp.then = function(onFulfilled, onRejected) {
var capabilityResolve;
var capabilityReject;
var capabilityPromise = new this.constructor(function(resolve, reject) {
capabilityResolve = resolve;
capabilityReject = reject;
});
if (typeof capabilityResolve !== "function") {
throw new TypeError('Uncallable Promise resolve function');
}
if (typeof capabilityReject !== "function") {
throw new TypeError('Uncallable Promise reject function');
}
if (onFulfilled === undefined || onFulfilled === null) {
onFulfilled = identity;
}
if (onRejected === undefined || onRejected === null) {
onRejected = raise;
}
var promiseSlots = slots(this);
var state = promiseSlots.state;
if (state === PENDING_STATE) {
promiseSlots.fulfillReactions.push(makeReaction(
capabilityResolve,
capabilityReject,
onFulfilled
));
promiseSlots.rejectReactions.push(makeReaction(
capabilityResolve,
capabilityReject,
onRejected
));
} else if (state === FULFILLED_STATE || state === REJECTED_STATE) {
setImmediate(makeReaction(
capabilityResolve,
capabilityReject,
state === FULFILLED_STATE ? onFulfilled : onRejected,
promiseSlots.result
));
}
return capabilityPromise;
};
function makeReaction(resolve, reject, handler, argument) {
var hasArgument = arguments.length > 3;
return function(result) {
try {
result = handler(hasArgument ? argument : result);
} catch (err) {
reject(err);
return;
}
resolve(result);
};
}
/**
* When the .catch method is called with argument onRejected, the
* following steps are taken:
*
* people.mozilla.org/~jorendorff/es6-draft.html#sec-promise.prototype.catch
*/
Pp['catch'] = function(onRejected) {
return this.then(undefined, onRejected);
};
Pp.toString = function() {
return '[object Promise]';
};
return Promise;
}(/* jslint evil: true */ Function('return this')()));

88
Libraries/vendor/core/Promise.js vendored
View File

@ -1,88 +0,0 @@
/**
* @generated SignedSource<<a34c32acc93f914fafb29ca64341d514>>
*
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !! This file is a check-in of a static_upstream project! !!
* !! !!
* !! You should not modify this file directly. Instead: !!
* !! 1) Use `fjs use-upstream` to temporarily replace this with !!
* !! the latest version from upstream. !!
* !! 2) Make your changes, test them, etc. !!
* !! 3) Use `fjs push-upstream` to copy your changes back to !!
* !! static_upstream. !!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*
* Copyright 2013-2014 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @providesModule Promise
*
* This module wraps and augments the minimally ES6-compliant Promise
* implementation provided by the ES6Promise module.
*/
var Promise = require('ES6Promise');
var Pp = Promise.prototype;
var invariant = require('invariant');
var setImmediate = require('setImmediate');
var throwImmediate = require('throwImmediate');
/**
* Handle either fulfillment or rejection with the same callback.
*/
Pp.finally = function(onSettled) {
return this.then(onSettled, onSettled);
};
/**
* Throw any unhandled error in a separate tick of the event loop.
*/
Pp.done = function(onFulfilled, onRejected) {
this.then(onFulfilled, onRejected).then(null, throwImmediate);
};
/**
* This function takes an object with promises as keys and returns a promise.
* The returned promise is resolved when all promises from the object are
* resolved and gets rejected when the first promise is rejected.
*
* EXAMPLE:
* var promisedMuffin = Promise.allObject({
* dough: promisedDough,
* frosting: promisedFrosting
* }).then(function(results) {
* return combine(results.dough, results.frosting);
* });
*/
Promise.allObject = function(/*object*/ promises) {
// Throw instead of warn here to make sure people use this only with object.
invariant(
!Array.isArray(promises),
'expected an object, got an array instead'
);
var keys = Object.keys(promises);
return Promise.all(keys.map(function(key) {
return promises[key];
})).then(function(values) {
var answers = {};
values.forEach(function(value, i) {
answers[keys[i]] = value;
});
return answers;
});
};
module.exports = Promise;