kawaiipunk/laipower
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

updated plugin WP Mail SMTP version 2.5.0

Browse Source
This commit is contained in:
KawaiiPunk
2020-10-23 01:19:42 +00:00
committed by Gitium
parent 1047e0b29f
commit 51360a4729
205 changed files with 36345 additions and 921 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/Coroutine.php
View File

@ -9,7 +9,7 @@ use Throwable;
* Creates a promise that is resolved using a generator that yields values or
* promises (somewhat similar to C#'s async keyword).
*
* When called, the coroutine function will start an instance of the generator
* When called, the Coroutine::of method will start an instance of the generator
* and returns a promise that is fulfilled with its final yielded value.
*
* Control is returned back to the generator when the yielded promise settles.
@ -22,7 +22,7 @@ use Throwable;
* return new Promise\FulfilledPromise($value);
* }
*
* $promise = Promise\coroutine(function () {
* $promise = Promise\Coroutine::of(function () {
* $value = (yield createPromise('a'));
* try {
* $value = (yield createPromise($value . 'b'));
@ -38,6 +38,7 @@ use Throwable;
* @param callable $generatorFn Generator function to wrap into a promise.
*
* @return Promise
*
* @link https://github.com/petkaantonov/bluebird/blob/master/API.md#generators inspiration
*/
final class Coroutine implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
@ -62,7 +63,22 @@ final class Coroutine implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseIn
$this->currentPromise->wait();
}
});
$this->nextCoroutine($this->generator->current());
try {
$this->nextCoroutine($this->generator->current());
} catch (\Exception $exception) {
$this->result->reject($exception);
} catch (\Throwable $throwable) {
$this->result->reject($throwable);
}
}
/**
* Create a new coroutine.
*
* @return self
*/
public static function of(callable $generatorFn)
{
return new self($generatorFn);
}
public function then(callable $onFulfilled = null, callable $onRejected = null)
{
@ -95,7 +111,7 @@ final class Coroutine implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseIn
}
private function nextCoroutine($yielded)
{
$this->currentPromise = promise_for($yielded)->then([$this, '_handleSuccess'], [$this, '_handleFailure']);
$this->currentPromise = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::promiseFor($yielded)->then([$this, '_handleSuccess'], [$this, '_handleFailure']);
}
/**
* @internal
@ -123,7 +139,7 @@ final class Coroutine implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseIn
{
unset($this->currentPromise);
try {
$nextYield = $this->generator->throw(exception_for($reason));
$nextYield = $this->generator->throw(\WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::exceptionFor($reason));
// The throw was caught, so keep iterating on the coroutine
$this->nextCoroutine($nextYield);
} catch (\Exception $exception) {

75
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/Create.php Normal file
View File

@ -0,0 +1,75 @@
<?php
namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
final class Create
{
/**
* Creates a promise for a value if the value is not a promise.
*
* @param mixed $value Promise or value.
*
* @return PromiseInterface
*/
public static function promiseFor($value)
{
if ($value instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
return $value;
}
// Return a Guzzle promise that shadows the given promise.
if (\is_object($value) && \method_exists($value, 'then')) {
$wfn = \method_exists($value, 'wait') ? [$value, 'wait'] : null;
$cfn = \method_exists($value, 'cancel') ? [$value, 'cancel'] : null;
$promise = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise($wfn, $cfn);
$value->then([$promise, 'resolve'], [$promise, 'reject']);
return $promise;
}
return new \WPMailSMTP\Vendor\GuzzleHttp\Promise\FulfilledPromise($value);
}
/**
* Creates a rejected promise for a reason if the reason is not a promise.
* If the provided reason is a promise, then it is returned as-is.
*
* @param mixed $reason Promise or reason.
*
* @return PromiseInterface
*/
public static function rejectionFor($reason)
{
if ($reason instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
return $reason;
}
return new \WPMailSMTP\Vendor\GuzzleHttp\Promise\RejectedPromise($reason);
}
/**
* Create an exception for a rejected promise value.
*
* @param mixed $reason
*
* @return \Exception|\Throwable
*/
public static function exceptionFor($reason)
{
if ($reason instanceof \Exception || $reason instanceof \Throwable) {
return $reason;
}
return new \WPMailSMTP\Vendor\GuzzleHttp\Promise\RejectionException($reason);
}
/**
* Returns an iterator for the given value.
*
* @param mixed $value
*
* @return \Iterator
*/
public static function iterFor($value)
{
if ($value instanceof \Iterator) {
return $value;
}
if (\is_array($value)) {
return new \ArrayIterator($value);
}
return new \ArrayIterator([$value]);
}
}

66
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/Each.php Normal file
View File

@ -0,0 +1,66 @@
<?php
namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
final class Each
{
/**
* Given an iterator that yields promises or values, returns a promise that
* is fulfilled with a null value when the iterator has been consumed or
* the aggregate promise has been fulfilled or rejected.
*
* $onFulfilled is a function that accepts the fulfilled value, iterator
* index, and the aggregate promise. The callback can invoke any necessary
* side effects and choose to resolve or reject the aggregate if needed.
*
* $onRejected is a function that accepts the rejection reason, iterator
* index, and the aggregate promise. The callback can invoke any necessary
* side effects and choose to resolve or reject the aggregate if needed.
*
* @param mixed $iterable Iterator or array to iterate over.
* @param callable $onFulfilled
* @param callable $onRejected
*
* @return PromiseInterface
*/
public static function of($iterable, callable $onFulfilled = null, callable $onRejected = null)
{
return (new \WPMailSMTP\Vendor\GuzzleHttp\Promise\EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected]))->promise();
}
/**
* Like of, but only allows a certain number of outstanding promises at any
* given time.
*
* $concurrency may be an integer or a function that accepts the number of
* pending promises and returns a numeric concurrency limit value to allow
* for dynamic a concurrency size.
*
* @param mixed $iterable
* @param int|callable $concurrency
* @param callable $onFulfilled
* @param callable $onRejected
*
* @return PromiseInterface
*/
public static function ofLimit($iterable, $concurrency, callable $onFulfilled = null, callable $onRejected = null)
{
return (new \WPMailSMTP\Vendor\GuzzleHttp\Promise\EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected, 'concurrency' => $concurrency]))->promise();
}
/**
* Like limit, but ensures that no promise in the given $iterable argument
* is rejected. If any promise is rejected, then the aggregate promise is
* rejected with the encountered rejection.
*
* @param mixed $iterable
* @param int|callable $concurrency
* @param callable $onFulfilled
*
* @return PromiseInterface
*/
public static function ofLimitAll($iterable, $concurrency, callable $onFulfilled = null)
{
return each_limit($iterable, $concurrency, $onFulfilled, function ($reason, $idx, \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $aggregate) {
$aggregate->reject($reason);
});
}
}

61
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/EachPromise.php
View File

@ -9,17 +9,17 @@ namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInterface
{
private $pending = [];
/** @var \Iterator */
/** @var \Iterator|null */
private $iterable;
/** @var callable|int */
/** @var callable|int|null */
private $concurrency;
/** @var callable */
/** @var callable|null */
private $onFulfilled;
/** @var callable */
/** @var callable|null */
private $onRejected;
/** @var Promise */
/** @var Promise|null */
private $aggregate;
/** @var bool */
/** @var bool|null */
private $mutex;
/**
* Configuration hash can include the following key value pairs:
@ -39,12 +39,12 @@ class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInter
* allowed number of outstanding concurrently executing promises,
* creating a capped pool of promises. There is no limit by default.
*
* @param mixed $iterable Promises or values to iterate.
* @param array $config Configuration options
* @param mixed $iterable Promises or values to iterate.
* @param array $config Configuration options
*/
public function __construct($iterable, array $config = [])
{
$this->iterable = iter_for($iterable);
$this->iterable = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::iterFor($iterable);
if (isset($config['concurrency'])) {
$this->concurrency = $config['concurrency'];
}
@ -55,6 +55,7 @@ class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInter
$this->onRejected = $config['rejected'];
}
}
/** @psalm-suppress InvalidNullableReturnType */
public function promise()
{
if ($this->aggregate) {
@ -62,13 +63,28 @@ class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInter
}
try {
$this->createPromise();
/** @psalm-assert Promise $this->aggregate */
$this->iterable->rewind();
$this->refillPending();
if (!$this->checkIfFinished()) {
$this->refillPending();
}
} catch (\Throwable $e) {
/**
* @psalm-suppress NullReference
* @phpstan-ignore-next-line
*/
$this->aggregate->reject($e);
} catch (\Exception $e) {
/**
* @psalm-suppress NullReference
* @phpstan-ignore-next-line
*/
$this->aggregate->reject($e);
}
/**
* @psalm-suppress NullableReturnStatement
* @phpstan-ignore-next-line
*/
return $this->aggregate;
}
private function createPromise()
@ -76,16 +92,12 @@ class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInter
$this->mutex = \false;
$this->aggregate = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise(function () {
\reset($this->pending);
if (empty($this->pending) && !$this->iterable->valid()) {
$this->aggregate->resolve(null);
return;
}
// Consume a potentially fluctuating list of promises while
// ensuring that indexes are maintained (precluding array_shift).
while ($promise = \current($this->pending)) {
\next($this->pending);
$promise->wait();
if ($this->aggregate->getState() !== \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::PENDING) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::settled($this->aggregate)) {
return;
}
}
@ -126,16 +138,21 @@ class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInter
if (!$this->iterable || !$this->iterable->valid()) {
return \false;
}
$promise = promise_for($this->iterable->current());
$idx = $this->iterable->key();
$this->pending[$idx] = $promise->then(function ($value) use($idx) {
$promise = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::promiseFor($this->iterable->current());
$key = $this->iterable->key();
// Iterable keys may not be unique, so we add the promises at the end
// of the pending array and retrieve the array index being used
$this->pending[] = null;
\end($this->pending);
$idx = \key($this->pending);
$this->pending[$idx] = $promise->then(function ($value) use($idx, $key) {
if ($this->onFulfilled) {
\call_user_func($this->onFulfilled, $value, $idx, $this->aggregate);
\call_user_func($this->onFulfilled, $value, $key, $this->aggregate);
}
$this->step($idx);
}, function ($reason) use($idx) {
}, function ($reason) use($idx, $key) {
if ($this->onRejected) {
\call_user_func($this->onRejected, $reason, $idx, $this->aggregate);
\call_user_func($this->onRejected, $reason, $key, $this->aggregate);
}
$this->step($idx);
});
@ -166,7 +183,7 @@ class EachPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromisorInter
private function step($idx)
{
// If the promise was already resolved, then ignore this step.
if ($this->aggregate->getState() !== \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::PENDING) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::settled($this->aggregate)) {
return;
}
unset($this->pending[$idx]);

6
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/FulfilledPromise.php
View File

@ -13,7 +13,7 @@ class FulfilledPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseI
private $value;
public function __construct($value)
{
if (\method_exists($value, 'then')) {
if (\is_object($value) && \method_exists($value, 'then')) {
throw new \InvalidArgumentException('You cannot create a FulfilledPromise with a promise.');
}
$this->value = $value;
@ -24,11 +24,11 @@ class FulfilledPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseI
if (!$onFulfilled) {
return $this;
}
$queue = queue();
$queue = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::queue();
$p = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise([$queue, 'run']);
$value = $this->value;
$queue->add(static function () use($p, $value, $onFulfilled) {
if ($p->getState() === self::PENDING) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::pending($p)) {
try {
$p->resolve($onFulfilled($value));
} catch (\Throwable $e) {

43
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/Is.php Normal file
View File

@ -0,0 +1,43 @@
<?php
namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
final class Is
{
/**
* Returns true if a promise is pending.
*
* @return bool
*/
public static function pending(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() === \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::PENDING;
}
/**
* Returns true if a promise is fulfilled or rejected.
*
* @return bool
*/
public static function settled(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() !== \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::PENDING;
}
/**
* Returns true if a promise is fulfilled.
*
* @return bool
*/
public static function fulfilled(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() === \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::FULFILLED;
}
/**
* Returns true if a promise is rejected.
*
* @return bool
*/
public static function rejected(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() === \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED;
}
}

58
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/Promise.php
View File

@ -35,11 +35,12 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
}
// Return a fulfilled promise and immediately invoke any callbacks.
if ($this->state === self::FULFILLED) {
return $onFulfilled ? promise_for($this->result)->then($onFulfilled) : promise_for($this->result);
$promise = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::promiseFor($this->result);
return $onFulfilled ? $promise->then($onFulfilled) : $promise;
}
// It's either cancelled or rejected, so return a rejected promise
// and immediately invoke any callbacks.
$rejection = rejection_for($this->result);
$rejection = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::rejectionFor($this->result);
return $onRejected ? $rejection->then(null, $onRejected) : $rejection;
}
public function otherwise(callable $onRejected)
@ -49,14 +50,15 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
public function wait($unwrap = \true)
{
$this->waitIfPending();
$inner = $this->result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface ? $this->result->wait($unwrap) : $this->result;
if ($this->result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
return $this->result->wait($unwrap);
}
if ($unwrap) {
if ($this->result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface || $this->state === self::FULFILLED) {
return $inner;
} else {
// It's rejected so "unwrap" and throw an exception.
throw exception_for($inner);
if ($this->state === self::FULFILLED) {
return $this->result;
}
// It's rejected so "unwrap" and throw an exception.
throw \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::exceptionFor($this->result);
}
}
public function getState()
@ -81,6 +83,7 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
}
}
// Reject the promise only if it wasn't rejected in a then callback.
/** @psalm-suppress RedundantCondition */
if ($this->state === self::PENDING) {
$this->reject(new \WPMailSMTP\Vendor\GuzzleHttp\Promise\CancellationException('Promise has been cancelled'));
}
@ -117,15 +120,15 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
}
// If the value was not a settled promise or a thenable, then resolve
// it in the task queue using the correct ID.
if (!\method_exists($value, 'then')) {
if (!\is_object($value) || !\method_exists($value, 'then')) {
$id = $state === self::FULFILLED ? 1 : 2;
// It's a success, so resolve the handlers in the queue.
queue()->add(static function () use($id, $value, $handlers) {
\WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::queue()->add(static function () use($id, $value, $handlers) {
foreach ($handlers as $handler) {
self::callHandler($id, $value, $handler);
}
});
} elseif ($value instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise && $value->getState() === self::PENDING) {
} elseif ($value instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise && \WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::pending($value)) {
// We can just merge our handlers onto the next promise.
$value->handlers = \array_merge($value->handlers, $handlers);
} else {
@ -147,8 +150,6 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
* @param int $index 1 (resolve) or 2 (reject).
* @param mixed $value Value to pass to the callback.
* @param array $handler Array of handler data (promise and callbacks).
*
* @return array Returns the next group to resolve.
*/
private static function callHandler($index, $value, array $handler)
{
@ -156,12 +157,20 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
$promise = $handler[0];
// The promise may have been cancelled or resolved before placing
// this thunk in the queue.
if ($promise->getState() !== self::PENDING) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::settled($promise)) {
return;
}
try {
if (isset($handler[$index])) {
$promise->resolve($handler[$index]($value));
/*
* If $f throws an exception, then $handler will be in the exception
* stack trace. Since $handler contains a reference to the callable
* itself we get a circular reference. We clear the $handler
* here to avoid that memory leak.
*/
$f = $handler[$index];
unset($handler);
$promise->resolve($f($value));
} elseif ($index === 1) {
// Forward resolution values as-is.
$promise->resolve($value);
@ -184,10 +193,11 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
} elseif ($this->waitList) {
$this->invokeWaitList();
} else {
// If there's not wait function, then reject the promise.
// If there's no wait function, then reject the promise.
$this->reject('Cannot wait on a promise that has ' . 'no internal wait function. You must provide a wait ' . 'function when constructing the promise to be able to ' . 'wait on a promise.');
}
queue()->run();
\WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::queue()->run();
/** @psalm-suppress RedundantCondition */
if ($this->state === self::PENDING) {
$this->reject('Invoking the wait callback did not resolve the promise');
}
@ -215,16 +225,12 @@ class Promise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface
$waitList = $this->waitList;
$this->waitList = null;
foreach ($waitList as $result) {
while (\true) {
do {
$result->waitIfPending();
if ($result->result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise) {
$result = $result->result;
} else {
if ($result->result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
$result->result->wait(\false);
}
break;
}
$result = $result->result;
} while ($result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise);
if ($result instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
$result->wait(\false);
}
}
}

3
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/PromiseInterface.php
View File

@ -50,6 +50,7 @@ interface PromiseInterface
* Resolve the promise with the given value.
*
* @param mixed $value
*
* @throws \RuntimeException if the promise is already resolved.
*/
public function resolve($value);
@ -57,6 +58,7 @@ interface PromiseInterface
* Reject the promise with the given reason.
*
* @param mixed $reason
*
* @throws \RuntimeException if the promise is already resolved.
*/
public function reject($reason);
@ -77,6 +79,7 @@ interface PromiseInterface
* @param bool $unwrap
*
* @return mixed
*
* @throws \LogicException if the promise has no wait function or if the
* promise does not settle after waiting.
*/

9
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/RejectedPromise.php
View File

@ -13,7 +13,7 @@ class RejectedPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseIn
private $reason;
public function __construct($reason)
{
if (\method_exists($reason, 'then')) {
if (\is_object($reason) && \method_exists($reason, 'then')) {
throw new \InvalidArgumentException('You cannot create a RejectedPromise with a promise.');
}
$this->reason = $reason;
@ -24,11 +24,11 @@ class RejectedPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseIn
if (!$onRejected) {
return $this;
}
$queue = queue();
$queue = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::queue();
$reason = $this->reason;
$p = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise([$queue, 'run']);
$queue->add(static function () use($p, $reason, $onRejected) {
if ($p->getState() === self::PENDING) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::pending($p)) {
try {
// Return a resolved promise if onRejected does not throw.
$p->resolve($onRejected($reason));
@ -50,8 +50,9 @@ class RejectedPromise implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseIn
public function wait($unwrap = \true, $defaultDelivery = null)
{
if ($unwrap) {
throw exception_for($this->reason);
throw \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::exceptionFor($this->reason);
}
return null;
}
public function getState()
{

2
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/RejectionException.php
View File

@ -12,7 +12,7 @@ class RejectionException extends \RuntimeException
/** @var mixed Rejection reason. */
private $reason;
/**
* @param mixed $reason Rejection reason.
* @param mixed $reason Rejection reason.
* @param string $description Optional description
*/
public function __construct($reason, $description = null)

4
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/TaskQueue.php
View File

@ -9,7 +9,7 @@ namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
* maintains a constant stack size. You can use the task queue asynchronously
* by calling the `run()` function of the global task queue in an event loop.
*
* GuzzleHttp\Promise\queue()->run();
* GuzzleHttp\Promise\Utils::queue()->run();
*/
class TaskQueue implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueueInterface
{
@ -39,8 +39,8 @@ class TaskQueue implements \WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueueInterf
}
public function run()
{
/** @var callable $task */
while ($task = \array_shift($this->queue)) {
/** @var callable $task */
$task();
}
}

2
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/TaskQueueInterface.php
View File

@ -13,8 +13,6 @@ interface TaskQueueInterface
/**
* Adds a task to the queue that will be executed the next time run is
* called.
*
* @param callable $task
*/
public function add(callable $task);
/**

237
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/Utils.php Normal file
View File

@ -0,0 +1,237 @@
<?php
namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
final class Utils
{
/**
* Get the global task queue used for promise resolution.
*
* This task queue MUST be run in an event loop in order for promises to be
* settled asynchronously. It will be automatically run when synchronously
* waiting on a promise.
*
* <code>
* while ($eventLoop->isRunning()) {
* GuzzleHttp\Promise\Utils::queue()->run();
* }
* </code>
*
* @param TaskQueueInterface $assign Optionally specify a new queue instance.
*
* @return TaskQueueInterface
*/
public static function queue(\WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueueInterface $assign = null)
{
static $queue;
if ($assign) {
$queue = $assign;
} elseif (!$queue) {
$queue = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueue();
}
return $queue;
}
/**
* Adds a function to run in the task queue when it is next `run()` and
* returns a promise that is fulfilled or rejected with the result.
*
* @param callable $task Task function to run.
*
* @return PromiseInterface
*/
public static function task(callable $task)
{
$queue = self::queue();
$promise = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise([$queue, 'run']);
$queue->add(function () use($task, $promise) {
try {
$promise->resolve($task());
} catch (\Throwable $e) {
$promise->reject($e);
} catch (\Exception $e) {
$promise->reject($e);
}
});
return $promise;
}
/**
* Synchronously waits on a promise to resolve and returns an inspection
* state array.
*
* Returns a state associative array containing a "state" key mapping to a
* valid promise state. If the state of the promise is "fulfilled", the
* array will contain a "value" key mapping to the fulfilled value of the
* promise. If the promise is rejected, the array will contain a "reason"
* key mapping to the rejection reason of the promise.
*
* @param PromiseInterface $promise Promise or value.
*
* @return array
*/
public static function inspect(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
try {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::FULFILLED, 'value' => $promise->wait()];
} catch (\WPMailSMTP\Vendor\GuzzleHttp\Promise\RejectionException $e) {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $e->getReason()];
} catch (\Throwable $e) {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $e];
} catch (\Exception $e) {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $e];
}
}
/**
* Waits on all of the provided promises, but does not unwrap rejected
* promises as thrown exception.
*
* Returns an array of inspection state arrays.
*
* @see inspect for the inspection state array format.
*
* @param PromiseInterface[] $promises Traversable of promises to wait upon.
*
* @return array
*/
public static function inspectAll($promises)
{
$results = [];
foreach ($promises as $key => $promise) {
$results[$key] = inspect($promise);
}
return $results;
}
/**
* Waits on all of the provided promises and returns the fulfilled values.
*
* Returns an array that contains the value of each promise (in the same
* order the promises were provided). An exception is thrown if any of the
* promises are rejected.
*
* @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
*
* @return array
*
* @throws \Exception on error
* @throws \Throwable on error in PHP >=7
*/
public static function unwrap($promises)
{
$results = [];
foreach ($promises as $key => $promise) {
$results[$key] = $promise->wait();
}
return $results;
}
/**
* Given an array of promises, return a promise that is fulfilled when all
* the items in the array are fulfilled.
*
* The promise's fulfillment value is an array with fulfillment values at
* respective positions to the original array. If any promise in the array
* rejects, the returned promise is rejected with the rejection reason.
*
* @param mixed $promises Promises or values.
* @param bool $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
*
* @return PromiseInterface
*/
public static function all($promises, $recursive = \false)
{
$results = [];
$promise = \WPMailSMTP\Vendor\GuzzleHttp\Promise\Each::of($promises, function ($value, $idx) use(&$results) {
$results[$idx] = $value;
}, function ($reason, $idx, \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise $aggregate) {
$aggregate->reject($reason);
})->then(function () use(&$results) {
\ksort($results);
return $results;
});
if (\true === $recursive) {
$promise = $promise->then(function ($results) use($recursive, &$promises) {
foreach ($promises as $promise) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::pending($promise)) {
return self::all($promises, $recursive);
}
}
return $results;
});
}
return $promise;
}
/**
* Initiate a competitive race between multiple promises or values (values
* will become immediately fulfilled promises).
*
* When count amount of promises have been fulfilled, the returned promise
* is fulfilled with an array that contains the fulfillment values of the
* winners in order of resolution.
*
* This promise is rejected with a {@see AggregateException} if the number
* of fulfilled promises is less than the desired $count.
*
* @param int $count Total number of promises.
* @param mixed $promises Promises or values.
*
* @return PromiseInterface
*/
public static function some($count, $promises)
{
$results = [];
$rejections = [];
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Each::of($promises, function ($value, $idx, \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $p) use(&$results, $count) {
if (\WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::settled($p)) {
return;
}
$results[$idx] = $value;
if (\count($results) >= $count) {
$p->resolve(null);
}
}, function ($reason) use(&$rejections) {
$rejections[] = $reason;
})->then(function () use(&$results, &$rejections, $count) {
if (\count($results) !== $count) {
throw new \WPMailSMTP\Vendor\GuzzleHttp\Promise\AggregateException('Not enough promises to fulfill count', $rejections);
}
\ksort($results);
return \array_values($results);
});
}
/**
* Like some(), with 1 as count. However, if the promise fulfills, the
* fulfillment value is not an array of 1 but the value directly.
*
* @param mixed $promises Promises or values.
*
* @return PromiseInterface
*/
public static function any($promises)
{
return self::some(1, $promises)->then(function ($values) {
return $values[0];
});
}
/**
* Returns a promise that is fulfilled when all of the provided promises have
* been fulfilled or rejected.
*
* The returned promise is fulfilled with an array of inspection state arrays.
*
* @see inspect for the inspection state array format.
*
* @param mixed $promises Promises or values.
*
* @return PromiseInterface
*/
public static function settle($promises)
{
$results = [];
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Each::of($promises, function ($value, $idx) use(&$results) {
$results[$idx] = ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::FULFILLED, 'value' => $value];
}, function ($reason, $idx) use(&$results) {
$results[$idx] = ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $reason];
})->then(function () use(&$results) {
\ksort($results);
return $results;
});
}
}

211
wp-content/plugins/wp-mail-smtp/vendor_prefixed/guzzlehttp/promises/src/functions.php
View File

@ -18,16 +18,12 @@ namespace WPMailSMTP\Vendor\GuzzleHttp\Promise;
* @param TaskQueueInterface $assign Optionally specify a new queue instance.
*
* @return TaskQueueInterface
*
* @deprecated queue will be removed in guzzlehttp/promises:2.0. Use Utils::queue instead.
*/
function queue(\WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueueInterface $assign = null)
{
static $queue;
if ($assign) {
$queue = $assign;
} elseif (!$queue) {
$queue = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueue();
}
return $queue;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::queue($assign);
}
/**
* Adds a function to run in the task queue when it is next `run()` and returns
@ -36,21 +32,12 @@ function queue(\WPMailSMTP\Vendor\GuzzleHttp\Promise\TaskQueueInterface $assign
* @param callable $task Task function to run.
*
* @return PromiseInterface
*
* @deprecated task will be removed in guzzlehttp/promises:2.0. Use Utils::task instead.
*/
function task(callable $task)
{
$queue = queue();
$promise = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise([$queue, 'run']);
$queue->add(function () use($task, $promise) {
try {
$promise->resolve($task());
} catch (\Throwable $e) {
$promise->reject($e);
} catch (\Exception $e) {
$promise->reject($e);
}
});
return $promise;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::task($task);
}
/**
* Creates a promise for a value if the value is not a promise.
@ -58,21 +45,12 @@ function task(callable $task)
* @param mixed $value Promise or value.
*
* @return PromiseInterface
*
* @deprecated promise_for will be removed in guzzlehttp/promises:2.0. Use Create::promiseFor instead.
*/
function promise_for($value)
{
if ($value instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
return $value;
}
// Return a Guzzle promise that shadows the given promise.
if (\method_exists($value, 'then')) {
$wfn = \method_exists($value, 'wait') ? [$value, 'wait'] : null;
$cfn = \method_exists($value, 'cancel') ? [$value, 'cancel'] : null;
$promise = new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise($wfn, $cfn);
$value->then([$promise, 'resolve'], [$promise, 'reject']);
return $promise;
}
return new \WPMailSMTP\Vendor\GuzzleHttp\Promise\FulfilledPromise($value);
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::promiseFor($value);
}
/**
* Creates a rejected promise for a reason if the reason is not a promise. If
@ -81,13 +59,12 @@ function promise_for($value)
* @param mixed $reason Promise or reason.
*
* @return PromiseInterface
*
* @deprecated rejection_for will be removed in guzzlehttp/promises:2.0. Use Create::rejectionFor instead.
*/
function rejection_for($reason)
{
if ($reason instanceof \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface) {
return $reason;
}
return new \WPMailSMTP\Vendor\GuzzleHttp\Promise\RejectedPromise($reason);
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::rejectionFor($reason);
}
/**
* Create an exception for a rejected promise value.
@ -95,10 +72,12 @@ function rejection_for($reason)
* @param mixed $reason
*
* @return \Exception|\Throwable
*
* @deprecated exception_for will be removed in guzzlehttp/promises:2.0. Use Create::exceptionFor instead.
*/
function exception_for($reason)
{
return $reason instanceof \Exception || $reason instanceof \Throwable ? $reason : new \WPMailSMTP\Vendor\GuzzleHttp\Promise\RejectionException($reason);
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::exceptionFor($reason);
}
/**
* Returns an iterator for the given value.
@ -106,16 +85,12 @@ function exception_for($reason)
* @param mixed $value
*
* @return \Iterator
*
* @deprecated iter_for will be removed in guzzlehttp/promises:2.0. Use Create::iterFor instead.
*/
function iter_for($value)
{
if ($value instanceof \Iterator) {
return $value;
} elseif (\is_array($value)) {
return new \ArrayIterator($value);
} else {
return new \ArrayIterator([$value]);
}
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Create::iterFor($value);
}
/**
* Synchronously waits on a promise to resolve and returns an inspection state
@ -130,18 +105,12 @@ function iter_for($value)
* @param PromiseInterface $promise Promise or value.
*
* @return array
*
* @deprecated inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspect instead.
*/
function inspect(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
try {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::FULFILLED, 'value' => $promise->wait()];
} catch (\WPMailSMTP\Vendor\GuzzleHttp\Promise\RejectionException $e) {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $e->getReason()];
} catch (\Throwable $e) {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $e];
} catch (\Exception $e) {
return ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $e];
}
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::inspect($promise);
}
/**
* Waits on all of the provided promises, but does not unwrap rejected promises
@ -149,18 +118,17 @@ function inspect(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise
*
* Returns an array of inspection state arrays.
*
* @see inspect for the inspection state array format.
*
* @param PromiseInterface[] $promises Traversable of promises to wait upon.
*
* @return array
* @see GuzzleHttp\Promise\inspect for the inspection state array format.
*
* @deprecated inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspectAll instead.
*/
function inspect_all($promises)
{
$results = [];
foreach ($promises as $key => $promise) {
$results[$key] = inspect($promise);
}
return $results;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::inspectAll($promises);
}
/**
* Waits on all of the provided promises and returns the fulfilled values.
@ -169,19 +137,18 @@ function inspect_all($promises)
* the promises were provided). An exception is thrown if any of the promises
* are rejected.
*
* @param mixed $promises Iterable of PromiseInterface objects to wait on.
* @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
*
* @return array
*
* @throws \Exception on error
* @throws \Throwable on error in PHP >=7
*
* @deprecated unwrap will be removed in guzzlehttp/promises:2.0. Use Utils::unwrap instead.
*/
function unwrap($promises)
{
$results = [];
foreach ($promises as $key => $promise) {
$results[$key] = $promise->wait();
}
return $results;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::unwrap($promises);
}
/**
* Given an array of promises, return a promise that is fulfilled when all the
@ -191,21 +158,16 @@ function unwrap($promises)
* respective positions to the original array. If any promise in the array
* rejects, the returned promise is rejected with the rejection reason.
*
* @param mixed $promises Promises or values.
* @param mixed $promises Promises or values.
* @param bool $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
*
* @return PromiseInterface
*
* @deprecated all will be removed in guzzlehttp/promises:2.0. Use Utils::all instead.
*/
function all($promises)
function all($promises, $recursive = \false)
{
$results = [];
return \each($promises, function ($value, $idx) use(&$results) {
$results[$idx] = $value;
}, function ($reason, $idx, \WPMailSMTP\Vendor\GuzzleHttp\Promise\Promise $aggregate) {
$aggregate->reject($reason);
})->then(function () use(&$results) {
\ksort($results);
return $results;
});
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::all($promises, $recursive);
}
/**
* Initiate a competitive race between multiple promises or values (values will
@ -215,35 +177,19 @@ function all($promises)
* fulfilled with an array that contains the fulfillment values of the winners
* in order of resolution.
*
* This prommise is rejected with a {@see GuzzleHttp\Promise\AggregateException}
* if the number of fulfilled promises is less than the desired $count.
* This promise is rejected with a {@see AggregateException} if the number of
* fulfilled promises is less than the desired $count.
*
* @param int $count Total number of promises.
* @param mixed $promises Promises or values.
*
* @return PromiseInterface
*
* @deprecated some will be removed in guzzlehttp/promises:2.0. Use Utils::some instead.
*/
function some($count, $promises)
{
$results = [];
$rejections = [];
return \each($promises, function ($value, $idx, \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $p) use(&$results, $count) {
if ($p->getState() !== \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::PENDING) {
return;
}
$results[$idx] = $value;
if (\count($results) >= $count) {
$p->resolve(null);
}
}, function ($reason) use(&$rejections) {
$rejections[] = $reason;
})->then(function () use(&$results, &$rejections, $count) {
if (\count($results) !== $count) {
throw new \WPMailSMTP\Vendor\GuzzleHttp\Promise\AggregateException('Not enough promises to fulfill count', $rejections);
}
\ksort($results);
return \array_values($results);
});
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::some($count, $promises);
}
/**
* Like some(), with 1 as count. However, if the promise fulfills, the
@ -252,12 +198,12 @@ function some($count, $promises)
* @param mixed $promises Promises or values.
*
* @return PromiseInterface
*
* @deprecated any will be removed in guzzlehttp/promises:2.0. Use Utils::any instead.
*/
function any($promises)
{
return some(1, $promises)->then(function ($values) {
return $values[0];
});
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::any($promises);
}
/**
* Returns a promise that is fulfilled when all of the provided promises have
@ -265,45 +211,42 @@ function any($promises)
*
* The returned promise is fulfilled with an array of inspection state arrays.
*
* @see inspect for the inspection state array format.
*
* @param mixed $promises Promises or values.
*
* @return PromiseInterface
* @see GuzzleHttp\Promise\inspect for the inspection state array format.
*
* @deprecated settle will be removed in guzzlehttp/promises:2.0. Use Utils::settle instead.
*/
function settle($promises)
{
$results = [];
return \each($promises, function ($value, $idx) use(&$results) {
$results[$idx] = ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::FULFILLED, 'value' => $value];
}, function ($reason, $idx) use(&$results) {
$results[$idx] = ['state' => \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED, 'reason' => $reason];
})->then(function () use(&$results) {
\ksort($results);
return $results;
});
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Utils::settle($promises);
}
/**
* Given an iterator that yields promises or values, returns a promise that is
* fulfilled with a null value when the iterator has been consumed or the
* aggregate promise has been fulfilled or rejected.
*
* $onFulfilled is a function that accepts the fulfilled value, iterator
* index, and the aggregate promise. The callback can invoke any necessary side
* effects and choose to resolve or reject the aggregate promise if needed.
* $onFulfilled is a function that accepts the fulfilled value, iterator index,
* and the aggregate promise. The callback can invoke any necessary side
* effects and choose to resolve or reject the aggregate if needed.
*
* $onRejected is a function that accepts the rejection reason, iterator
* index, and the aggregate promise. The callback can invoke any necessary side
* effects and choose to resolve or reject the aggregate promise if needed.
* $onRejected is a function that accepts the rejection reason, iterator index,
* and the aggregate promise. The callback can invoke any necessary side
* effects and choose to resolve or reject the aggregate if needed.
*
* @param mixed $iterable Iterator or array to iterate over.
* @param callable $onFulfilled
* @param callable $onRejected
*
* @return PromiseInterface
*
* @deprecated each will be removed in guzzlehttp/promises:2.0. Use Each::of instead.
*/
function each($iterable, callable $onFulfilled = null, callable $onRejected = null)
{
return (new \WPMailSMTP\Vendor\GuzzleHttp\Promise\EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected]))->promise();
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Each::of($iterable, $onFulfilled, $onRejected);
}
/**
* Like each, but only allows a certain number of outstanding promises at any
@ -319,10 +262,12 @@ function each($iterable, callable $onFulfilled = null, callable $onRejected = nu
* @param callable $onRejected
*
* @return PromiseInterface
*
* @deprecated each_limit will be removed in guzzlehttp/promises:2.0. Use Each::ofLimit instead.
*/
function each_limit($iterable, $concurrency, callable $onFulfilled = null, callable $onRejected = null)
{
return (new \WPMailSMTP\Vendor\GuzzleHttp\Promise\EachPromise($iterable, ['fulfilled' => $onFulfilled, 'rejected' => $onRejected, 'concurrency' => $concurrency]))->promise();
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Each::ofLimit($iterable, $concurrency, $onFulfilled, $onRejected);
}
/**
* Like each_limit, but ensures that no promise in the given $iterable argument
@ -334,54 +279,56 @@ function each_limit($iterable, $concurrency, callable $onFulfilled = null, calla
* @param callable $onFulfilled
*
* @return PromiseInterface
*
* @deprecated each_limit_all will be removed in guzzlehttp/promises:2.0. Use Each::ofLimitAll instead.
*/
function each_limit_all($iterable, $concurrency, callable $onFulfilled = null)
{
return each_limit($iterable, $concurrency, $onFulfilled, function ($reason, $idx, \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $aggregate) {
$aggregate->reject($reason);
});
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Each::ofLimitAll($iterable, $concurrency, $onFulfilled);
}
/**
* Returns true if a promise is fulfilled.
*
* @param PromiseInterface $promise
*
* @return bool
*
* @deprecated is_fulfilled will be removed in guzzlehttp/promises:2.0. Use Is::fulfilled instead.
*/
function is_fulfilled(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() === \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::FULFILLED;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::fulfilled($promise);
}
/**
* Returns true if a promise is rejected.
*
* @param PromiseInterface $promise
*
* @return bool
*
* @deprecated is_rejected will be removed in guzzlehttp/promises:2.0. Use Is::rejected instead.
*/
function is_rejected(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() === \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::REJECTED;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::rejected($promise);
}
/**
* Returns true if a promise is fulfilled or rejected.
*
* @param PromiseInterface $promise
*
* @return bool
*
* @deprecated is_settled will be removed in guzzlehttp/promises:2.0. Use Is::settled instead.
*/
function is_settled(\WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface $promise)
{
return $promise->getState() !== \WPMailSMTP\Vendor\GuzzleHttp\Promise\PromiseInterface::PENDING;
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Is::settled($promise);
}
/**
* Create a new coroutine.
*
* @see Coroutine
*
* @param callable $generatorFn
*
* @return PromiseInterface
*
* @deprecated coroutine will be removed in guzzlehttp/promises:2.0. Use Coroutine::of instead.
*/
function coroutine(callable $generatorFn)
{
return new \WPMailSMTP\Vendor\GuzzleHttp\Promise\Coroutine($generatorFn);
return \WPMailSMTP\Vendor\GuzzleHttp\Promise\Coroutine::of($generatorFn);
}