John Messerly
ead4fe2e85
There are a few examples of classes like this:
```dart
@patch
class StringBuffer {
... various @patch members ...
// no @patch here
void _writeString(str) { ... }
}
```
we need to merge in those members too
R=vsm@google.com
Review URL: https://codereview.chromium.org/955513007
4791 lines
174 KiB
JavaScript
4791 lines
174 KiB
JavaScript
var async;
|
|
(function(async) {
|
|
'use strict';
|
|
dart.copyProperties(async, {
|
|
get _hasDocument() {
|
|
return dart.equals(dart.dinvokef(/* Unimplemented unknown name */JS, 'String', 'typeof document'), 'object');
|
|
}
|
|
});
|
|
// Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
|
|
function _invokeErrorHandler(errorHandler, error, stackTrace) {
|
|
if (dart.is(errorHandler, ZoneBinaryCallback)) {
|
|
return dart.dinvokef(errorHandler, error, stackTrace);
|
|
} else {
|
|
return dart.dinvokef(errorHandler, error);
|
|
}
|
|
}
|
|
// Function _registerErrorHandler: (Function, Zone) → Function
|
|
function _registerErrorHandler(errorHandler, zone) {
|
|
if (dart.is(errorHandler, ZoneBinaryCallback)) {
|
|
return zone.registerBinaryCallback(errorHandler);
|
|
} else {
|
|
return zone.registerUnaryCallback(dart.as(errorHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
}
|
|
}
|
|
class _UncaughtAsyncError extends AsyncError {
|
|
_UncaughtAsyncError(error, stackTrace) {
|
|
super.AsyncError(error, _getBestStackTrace(error, stackTrace));
|
|
}
|
|
static _getBestStackTrace(error, stackTrace) {
|
|
if (stackTrace !== null)
|
|
return stackTrace;
|
|
if (dart.is(error, core.Error)) {
|
|
return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
|
|
}
|
|
return null;
|
|
}
|
|
toString() {
|
|
let result = `Uncaught Error: ${this.error}`;
|
|
if (this.stackTrace !== null) {
|
|
result = `\nStack Trace:\n${this.stackTrace}`;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
let _BroadcastStream$ = dart.generic(function(T) {
|
|
class _BroadcastStream extends _ControllerStream$(T) {
|
|
_BroadcastStream(controller) {
|
|
super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$(T)));
|
|
}
|
|
get isBroadcast() {
|
|
return true;
|
|
}
|
|
}
|
|
return _BroadcastStream;
|
|
});
|
|
let _BroadcastStream = _BroadcastStream$(dynamic);
|
|
class _BroadcastSubscriptionLink extends dart.Object {
|
|
_BroadcastSubscriptionLink() {
|
|
this._next = null;
|
|
this._previous = null;
|
|
}
|
|
}
|
|
let _BroadcastSubscription$ = dart.generic(function(T) {
|
|
class _BroadcastSubscription extends _ControllerSubscription$(T) {
|
|
_BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
|
|
this._eventState = dart.as(null, core.int);
|
|
this._next = null;
|
|
this._previous = null;
|
|
super._ControllerSubscription(dart.as(controller, _StreamControllerLifecycle$(T)), onData, onError, onDone, cancelOnError);
|
|
this._next = this._previous = this;
|
|
}
|
|
get _controller() {
|
|
return dart.as(super._controller, _BroadcastStreamController);
|
|
}
|
|
_expectsEvent(eventId) {
|
|
return (this._eventState & _STATE_EVENT_ID) === eventId;
|
|
}
|
|
_toggleEventId() {
|
|
this._eventState = _STATE_EVENT_ID;
|
|
}
|
|
get _isFiring() {
|
|
return (this._eventState & _STATE_FIRING) !== 0;
|
|
}
|
|
_setRemoveAfterFiring() {
|
|
dart.assert(this._isFiring);
|
|
this._eventState = _STATE_REMOVE_AFTER_FIRING;
|
|
}
|
|
get _removeAfterFiring() {
|
|
return (this._eventState & _STATE_REMOVE_AFTER_FIRING) !== 0;
|
|
}
|
|
_onPause() {}
|
|
_onResume() {}
|
|
}
|
|
_BroadcastSubscription._STATE_EVENT_ID = 1;
|
|
_BroadcastSubscription._STATE_FIRING = 2;
|
|
_BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
|
|
return _BroadcastSubscription;
|
|
});
|
|
let _BroadcastSubscription = _BroadcastSubscription$(dynamic);
|
|
let _BroadcastStreamController$ = dart.generic(function(T) {
|
|
class _BroadcastStreamController extends dart.Object {
|
|
_BroadcastStreamController(_onListen, _onCancel) {
|
|
this._onListen = _onListen;
|
|
this._onCancel = _onCancel;
|
|
this._state = _STATE_INITIAL;
|
|
this._next = null;
|
|
this._previous = null;
|
|
this._addStreamState = null;
|
|
this._doneFuture = null;
|
|
this._next = this._previous = this;
|
|
}
|
|
get stream() {
|
|
return new _BroadcastStream(this);
|
|
}
|
|
get sink() {
|
|
return new _StreamSinkWrapper(this);
|
|
}
|
|
get isClosed() {
|
|
return (this._state & _STATE_CLOSED) !== 0;
|
|
}
|
|
get isPaused() {
|
|
return false;
|
|
}
|
|
get hasListener() {
|
|
return !dart.notNull(this._isEmpty);
|
|
}
|
|
get _hasOneListener() {
|
|
dart.assert(!dart.notNull(this._isEmpty));
|
|
return core.identical(this._next._next, this);
|
|
}
|
|
get _isFiring() {
|
|
return (this._state & _STATE_FIRING) !== 0;
|
|
}
|
|
get _isAddingStream() {
|
|
return (this._state & _STATE_ADDSTREAM) !== 0;
|
|
}
|
|
get _mayAddEvent() {
|
|
return this._state < _STATE_CLOSED;
|
|
}
|
|
_ensureDoneFuture() {
|
|
if (this._doneFuture !== null)
|
|
return this._doneFuture;
|
|
return this._doneFuture = new _Future();
|
|
}
|
|
get _isEmpty() {
|
|
return core.identical(this._next, this);
|
|
}
|
|
_addListener(subscription) {
|
|
dart.assert(core.identical(subscription._next, subscription));
|
|
subscription._previous = this._previous;
|
|
subscription._next = this;
|
|
this._previous._next = subscription;
|
|
this._previous = subscription;
|
|
subscription._eventState = this._state & _STATE_EVENT_ID;
|
|
}
|
|
_removeListener(subscription) {
|
|
dart.assert(core.identical(subscription._controller, this));
|
|
dart.assert(!dart.notNull(core.identical(subscription._next, subscription)));
|
|
let previous = subscription._previous;
|
|
let next = subscription._next;
|
|
previous._next = next;
|
|
next._previous = previous;
|
|
subscription._next = subscription._previous = subscription;
|
|
}
|
|
_subscribe(onData, onError, onDone, cancelOnError) {
|
|
if (this.isClosed) {
|
|
if (onDone === null)
|
|
onDone = _nullDoneHandler;
|
|
return new _DoneStreamSubscription(onDone);
|
|
}
|
|
let subscription = new _BroadcastSubscription(this, onData, onError, onDone, cancelOnError);
|
|
this._addListener(dart.as(subscription, _BroadcastSubscription$(T)));
|
|
if (core.identical(this._next, this._previous)) {
|
|
_runGuarded(this._onListen);
|
|
}
|
|
return dart.as(subscription, StreamSubscription$(T));
|
|
}
|
|
_recordCancel(subscription) {
|
|
if (core.identical(subscription._next, subscription))
|
|
return null;
|
|
dart.assert(!dart.notNull(core.identical(subscription._next, subscription)));
|
|
if (subscription._isFiring) {
|
|
subscription._setRemoveAfterFiring();
|
|
} else {
|
|
dart.assert(!dart.notNull(core.identical(subscription._next, subscription)));
|
|
this._removeListener(subscription);
|
|
if (dart.notNull(!dart.notNull(this._isFiring)) && dart.notNull(this._isEmpty)) {
|
|
this._callOnCancel();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
_recordPause(subscription) {}
|
|
_recordResume(subscription) {}
|
|
_addEventError() {
|
|
if (this.isClosed) {
|
|
return new core.StateError("Cannot add new events after calling close");
|
|
}
|
|
dart.assert(this._isAddingStream);
|
|
return new core.StateError("Cannot add new events while doing an addStream");
|
|
}
|
|
add(data) {
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._addEventError();
|
|
this._sendData(data);
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
error = _nonNullError(error);
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._addEventError();
|
|
let replacement = Zone.current.errorCallback(error, stackTrace);
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
this._sendError(error, stackTrace);
|
|
}
|
|
close() {
|
|
if (this.isClosed) {
|
|
dart.assert(this._doneFuture !== null);
|
|
return this._doneFuture;
|
|
}
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._addEventError();
|
|
this._state = _STATE_CLOSED;
|
|
let doneFuture = this._ensureDoneFuture();
|
|
this._sendDone();
|
|
return doneFuture;
|
|
}
|
|
get done() {
|
|
return this._ensureDoneFuture();
|
|
}
|
|
addStream(stream, opt$) {
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? true : opt$.cancelOnError;
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._addEventError();
|
|
this._state = _STATE_ADDSTREAM;
|
|
this._addStreamState = dart.as(new _AddStreamState(this, stream, cancelOnError), _AddStreamState$(T));
|
|
return this._addStreamState.addStreamFuture;
|
|
}
|
|
_add(data) {
|
|
this._sendData(data);
|
|
}
|
|
_addError(error, stackTrace) {
|
|
this._sendError(error, stackTrace);
|
|
}
|
|
_close() {
|
|
dart.assert(this._isAddingStream);
|
|
let addState = this._addStreamState;
|
|
this._addStreamState = null;
|
|
this._state = ~_STATE_ADDSTREAM;
|
|
addState.complete();
|
|
}
|
|
_forEachListener(action) {
|
|
if (this._isFiring) {
|
|
throw new core.StateError("Cannot fire new event. Controller is already firing an event");
|
|
}
|
|
if (this._isEmpty)
|
|
return;
|
|
let id = this._state & _STATE_EVENT_ID;
|
|
this._state = _STATE_EVENT_ID | _STATE_FIRING;
|
|
let link = this._next;
|
|
while (!dart.notNull(core.identical(link, this))) {
|
|
let subscription = dart.as(link, _BroadcastSubscription$(T));
|
|
if (subscription._expectsEvent(id)) {
|
|
subscription._eventState = _BroadcastSubscription._STATE_FIRING;
|
|
action(subscription);
|
|
subscription._toggleEventId();
|
|
link = subscription._next;
|
|
if (subscription._removeAfterFiring) {
|
|
this._removeListener(subscription);
|
|
}
|
|
subscription._eventState = ~_BroadcastSubscription._STATE_FIRING;
|
|
} else {
|
|
link = subscription._next;
|
|
}
|
|
}
|
|
this._state = ~_STATE_FIRING;
|
|
if (this._isEmpty) {
|
|
this._callOnCancel();
|
|
}
|
|
}
|
|
_callOnCancel() {
|
|
dart.assert(this._isEmpty);
|
|
if (dart.notNull(this.isClosed) && dart.notNull(this._doneFuture._mayComplete)) {
|
|
this._doneFuture._asyncComplete(null);
|
|
}
|
|
_runGuarded(this._onCancel);
|
|
}
|
|
}
|
|
_BroadcastStreamController._STATE_INITIAL = 0;
|
|
_BroadcastStreamController._STATE_EVENT_ID = 1;
|
|
_BroadcastStreamController._STATE_FIRING = 2;
|
|
_BroadcastStreamController._STATE_CLOSED = 4;
|
|
_BroadcastStreamController._STATE_ADDSTREAM = 8;
|
|
return _BroadcastStreamController;
|
|
});
|
|
let _BroadcastStreamController = _BroadcastStreamController$(dynamic);
|
|
let _SyncBroadcastStreamController$ = dart.generic(function(T) {
|
|
class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
|
|
_SyncBroadcastStreamController(onListen, onCancel) {
|
|
super._BroadcastStreamController(onListen, onCancel);
|
|
}
|
|
_sendData(data) {
|
|
if (this._isEmpty)
|
|
return;
|
|
if (this._hasOneListener) {
|
|
this._state = _BroadcastStreamController._STATE_FIRING;
|
|
let subscription = dart.as(this._next, _BroadcastSubscription);
|
|
subscription._add(data);
|
|
this._state = ~_BroadcastStreamController._STATE_FIRING;
|
|
if (this._isEmpty) {
|
|
this._callOnCancel();
|
|
}
|
|
return;
|
|
}
|
|
this._forEachListener(((subscription) => {
|
|
subscription._add(data);
|
|
}).bind(this));
|
|
}
|
|
_sendError(error, stackTrace) {
|
|
if (this._isEmpty)
|
|
return;
|
|
this._forEachListener(((subscription) => {
|
|
subscription._addError(error, stackTrace);
|
|
}).bind(this));
|
|
}
|
|
_sendDone() {
|
|
if (!dart.notNull(this._isEmpty)) {
|
|
this._forEachListener(dart.as(((subscription) => {
|
|
subscription._close();
|
|
}).bind(this), dart.throw_("Unimplemented type (_BufferingStreamSubscription<T>) → void")));
|
|
} else {
|
|
dart.assert(this._doneFuture !== null);
|
|
dart.assert(this._doneFuture._mayComplete);
|
|
this._doneFuture._asyncComplete(null);
|
|
}
|
|
}
|
|
}
|
|
return _SyncBroadcastStreamController;
|
|
});
|
|
let _SyncBroadcastStreamController = _SyncBroadcastStreamController$(dynamic);
|
|
let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
|
|
class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
|
|
_AsyncBroadcastStreamController(onListen, onCancel) {
|
|
super._BroadcastStreamController(onListen, onCancel);
|
|
}
|
|
_sendData(data) {
|
|
for (let link = this._next; !dart.notNull(core.identical(link, this)); link = link._next) {
|
|
let subscription = dart.as(link, _BroadcastSubscription$(T));
|
|
subscription._addPending(new _DelayedData(data));
|
|
}
|
|
}
|
|
_sendError(error, stackTrace) {
|
|
for (let link = this._next; !dart.notNull(core.identical(link, this)); link = link._next) {
|
|
let subscription = dart.as(link, _BroadcastSubscription$(T));
|
|
subscription._addPending(new _DelayedError(error, stackTrace));
|
|
}
|
|
}
|
|
_sendDone() {
|
|
if (!dart.notNull(this._isEmpty)) {
|
|
for (let link = this._next; !dart.notNull(core.identical(link, this)); link = link._next) {
|
|
let subscription = dart.as(link, _BroadcastSubscription$(T));
|
|
subscription._addPending(new _DelayedDone());
|
|
}
|
|
} else {
|
|
dart.assert(this._doneFuture !== null);
|
|
dart.assert(this._doneFuture._mayComplete);
|
|
this._doneFuture._asyncComplete(null);
|
|
}
|
|
}
|
|
}
|
|
return _AsyncBroadcastStreamController;
|
|
});
|
|
let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$(dynamic);
|
|
let _AsBroadcastStreamController$ = dart.generic(function(T) {
|
|
class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
|
|
_AsBroadcastStreamController(onListen, onCancel) {
|
|
this._pending = null;
|
|
super._SyncBroadcastStreamController(onListen, onCancel);
|
|
}
|
|
get _hasPending() {
|
|
return dart.notNull(this._pending !== null) && dart.notNull(!dart.notNull(this._pending.isEmpty));
|
|
}
|
|
_addPendingEvent(event) {
|
|
if (this._pending === null) {
|
|
this._pending = new _StreamImplEvents();
|
|
}
|
|
this._pending.add(event);
|
|
}
|
|
add(data) {
|
|
if (dart.notNull(!dart.notNull(this.isClosed)) && dart.notNull(this._isFiring)) {
|
|
this._addPendingEvent(new _DelayedData(data));
|
|
return;
|
|
}
|
|
super.add(data);
|
|
while (this._hasPending) {
|
|
this._pending.handleNext(this);
|
|
}
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
if (dart.notNull(!dart.notNull(this.isClosed)) && dart.notNull(this._isFiring)) {
|
|
this._addPendingEvent(new _DelayedError(error, stackTrace));
|
|
return;
|
|
}
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._addEventError();
|
|
this._sendError(error, stackTrace);
|
|
while (this._hasPending) {
|
|
this._pending.handleNext(this);
|
|
}
|
|
}
|
|
close() {
|
|
if (dart.notNull(!dart.notNull(this.isClosed)) && dart.notNull(this._isFiring)) {
|
|
this._addPendingEvent(new _DelayedDone());
|
|
this._state = _BroadcastStreamController._STATE_CLOSED;
|
|
return super.done;
|
|
}
|
|
let result = super.close();
|
|
dart.assert(!dart.notNull(this._hasPending));
|
|
return result;
|
|
}
|
|
_callOnCancel() {
|
|
if (this._hasPending) {
|
|
this._pending.clear();
|
|
this._pending = null;
|
|
}
|
|
super._callOnCancel();
|
|
}
|
|
}
|
|
return _AsBroadcastStreamController;
|
|
});
|
|
let _AsBroadcastStreamController = _AsBroadcastStreamController$(dynamic);
|
|
let _DoneSubscription$ = dart.generic(function(T) {
|
|
class _DoneSubscription extends dart.Object {
|
|
_DoneSubscription() {
|
|
this._pauseCount = 0;
|
|
}
|
|
onData(handleData) {}
|
|
onError(handleError) {}
|
|
onDone(handleDone) {}
|
|
pause(resumeSignal) {
|
|
if (resumeSignal === void 0)
|
|
resumeSignal = null;
|
|
if (resumeSignal !== null)
|
|
resumeSignal.then(this._resume);
|
|
this._pauseCount++;
|
|
}
|
|
resume() {
|
|
this._resume(null);
|
|
}
|
|
_resume(_) {
|
|
if (this._pauseCount > 0)
|
|
this._pauseCount--;
|
|
}
|
|
cancel() {
|
|
return new _Future.immediate(null);
|
|
}
|
|
get isPaused() {
|
|
return this._pauseCount > 0;
|
|
}
|
|
asFuture(value) {
|
|
if (value === void 0)
|
|
value = null;
|
|
return new _Future();
|
|
}
|
|
}
|
|
return _DoneSubscription;
|
|
});
|
|
let _DoneSubscription = _DoneSubscription$(dynamic);
|
|
class DeferredLibrary extends dart.Object {
|
|
DeferredLibrary(libraryName, opt$) {
|
|
let uri = opt$.uri === void 0 ? null : opt$.uri;
|
|
this.libraryName = libraryName;
|
|
this.uri = uri;
|
|
}
|
|
load() {
|
|
throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
|
|
}
|
|
}
|
|
class DeferredLoadException extends dart.Object {
|
|
DeferredLoadException(_s) {
|
|
this._s = _s;
|
|
}
|
|
toString() {
|
|
return `DeferredLoadException: '${this._s}'`;
|
|
}
|
|
}
|
|
let Future$ = dart.generic(function(T) {
|
|
class Future extends dart.Object {
|
|
Future(computation) {
|
|
let result = new _Future();
|
|
Timer.run((() => {
|
|
try {
|
|
result._complete(computation());
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(result, e, s);
|
|
}
|
|
|
|
}).bind(this));
|
|
return dart.as(result, Future$(T));
|
|
}
|
|
Future$microtask(computation) {
|
|
let result = new _Future();
|
|
scheduleMicrotask((() => {
|
|
try {
|
|
result._complete(computation());
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(result, e, s);
|
|
}
|
|
|
|
}).bind(this));
|
|
return dart.as(result, Future$(T));
|
|
}
|
|
Future$sync(computation) {
|
|
try {
|
|
let result = computation();
|
|
return new Future.value(result);
|
|
} catch (error) {
|
|
let stackTrace = dart.stackTrace(error);
|
|
return new Future.error(error, stackTrace);
|
|
}
|
|
|
|
}
|
|
Future$value(value) {
|
|
if (value === void 0)
|
|
value = null;
|
|
return new _Future.immediate(value);
|
|
}
|
|
Future$error(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
error = _nonNullError(error);
|
|
if (!dart.notNull(core.identical(Zone.current, _ROOT_ZONE))) {
|
|
let replacement = Zone.current.errorCallback(error, stackTrace);
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
}
|
|
return new _Future.immediateError(error, stackTrace);
|
|
}
|
|
Future$delayed(duration, computation) {
|
|
if (computation === void 0)
|
|
computation = null;
|
|
let result = new _Future();
|
|
new Timer(duration, (() => {
|
|
try {
|
|
result._complete(computation === null ? null : computation());
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(result, e, s);
|
|
}
|
|
|
|
}).bind(this));
|
|
return dart.as(result, Future$(T));
|
|
}
|
|
static wait(futures, opt$) {
|
|
let eagerError = opt$.eagerError === void 0 ? false : opt$.eagerError;
|
|
let cleanUp = opt$.cleanUp === void 0 ? null : opt$.cleanUp;
|
|
let result = new _Future();
|
|
let values = null;
|
|
let remaining = 0;
|
|
let error = null;
|
|
let stackTrace = null;
|
|
// Function handleError: (dynamic, dynamic) → void
|
|
function handleError(theError, theStackTrace) {
|
|
remaining--;
|
|
if (values !== null) {
|
|
if (cleanUp !== null) {
|
|
for (let value of values) {
|
|
if (value !== null) {
|
|
new Future.sync(() => {
|
|
cleanUp(value);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
values = null;
|
|
if (dart.notNull(remaining === 0) || dart.notNull(eagerError)) {
|
|
result._completeError(theError, dart.as(theStackTrace, core.StackTrace));
|
|
} else {
|
|
error = theError;
|
|
stackTrace = dart.as(theStackTrace, core.StackTrace);
|
|
}
|
|
} else if (dart.notNull(remaining === 0) && dart.notNull(!dart.notNull(eagerError))) {
|
|
result._completeError(error, stackTrace);
|
|
}
|
|
}
|
|
for (let future of futures) {
|
|
let pos = remaining++;
|
|
future.then(dart.as(((value) => {
|
|
remaining--;
|
|
if (values !== null) {
|
|
values.set(pos, value);
|
|
if (remaining === 0) {
|
|
result._completeWithValue(values);
|
|
}
|
|
} else {
|
|
if (dart.notNull(cleanUp !== null) && dart.notNull(value !== null)) {
|
|
new Future.sync(() => {
|
|
cleanUp(value);
|
|
});
|
|
}
|
|
if (dart.notNull(remaining === 0) && dart.notNull(!dart.notNull(eagerError))) {
|
|
result._completeError(error, stackTrace);
|
|
}
|
|
}
|
|
}).bind(this), dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: handleError});
|
|
}
|
|
if (remaining === 0) {
|
|
return dart.as(new Future.value(/* Unimplemented const */new List.from([])), Future$(core.List));
|
|
}
|
|
values = new core.List(remaining);
|
|
return result;
|
|
}
|
|
static forEach(input, f) {
|
|
let iterator = input.iterator;
|
|
return doWhile((() => {
|
|
if (!dart.notNull(iterator.moveNext()))
|
|
return false;
|
|
return new Future.sync((() => f(iterator.current)).bind(this)).then((_) => true);
|
|
}).bind(this));
|
|
}
|
|
static doWhile(f) {
|
|
let doneSignal = new _Future();
|
|
let nextIteration = null;
|
|
nextIteration = Zone.current.bindUnaryCallback(dart.as(((keepGoing) => {
|
|
if (keepGoing) {
|
|
new Future.sync(f).then(dart.as(nextIteration, dart.throw_("Unimplemented type (dynamic) → dynamic")), {onError: doneSignal._completeError});
|
|
} else {
|
|
doneSignal._complete(null);
|
|
}
|
|
}).bind(this), dart.throw_("Unimplemented type (dynamic) → dynamic")), {runGuarded: true});
|
|
dart.dinvokef(nextIteration, true);
|
|
return doneSignal;
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(Future, 'microtask');
|
|
dart.defineNamedConstructor(Future, 'sync');
|
|
dart.defineNamedConstructor(Future, 'value');
|
|
dart.defineNamedConstructor(Future, 'error');
|
|
dart.defineNamedConstructor(Future, 'delayed');
|
|
dart.defineLazyProperties(Future, {
|
|
get _nullFuture() {
|
|
return dart.as(new Future.value(null), _Future);
|
|
}
|
|
});
|
|
return Future;
|
|
});
|
|
let Future = Future$(dynamic);
|
|
class TimeoutException extends dart.Object {
|
|
TimeoutException(message, duration) {
|
|
if (duration === void 0)
|
|
duration = null;
|
|
this.message = message;
|
|
this.duration = duration;
|
|
}
|
|
toString() {
|
|
let result = "TimeoutException";
|
|
if (this.duration !== null)
|
|
result = `TimeoutException after ${this.duration}`;
|
|
if (this.message !== null)
|
|
result = `${result}: ${this.message}`;
|
|
return result;
|
|
}
|
|
}
|
|
let Completer$ = dart.generic(function(T) {
|
|
class Completer extends dart.Object {
|
|
Completer() {
|
|
return new _AsyncCompleter();
|
|
}
|
|
Completer$sync() {
|
|
return new _SyncCompleter();
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(Completer, 'sync');
|
|
return Completer;
|
|
});
|
|
let Completer = Completer$(dynamic);
|
|
// Function _completeWithErrorCallback: (_Future<dynamic>, dynamic, dynamic) → void
|
|
function _completeWithErrorCallback(result, error, stackTrace) {
|
|
let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
result._completeError(error, dart.as(stackTrace, core.StackTrace));
|
|
}
|
|
// Function _nonNullError: (Object) → Object
|
|
function _nonNullError(error) {
|
|
return error !== null ? error : new core.NullThrownError();
|
|
}
|
|
let _Completer$ = dart.generic(function(T) {
|
|
class _Completer extends dart.Object {
|
|
_Completer() {
|
|
this.future = new _Future();
|
|
}
|
|
completeError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
error = _nonNullError(error);
|
|
if (!dart.notNull(this.future._mayComplete))
|
|
throw new core.StateError("Future already completed");
|
|
let replacement = Zone.current.errorCallback(error, stackTrace);
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
this._completeError(error, stackTrace);
|
|
}
|
|
get isCompleted() {
|
|
return !dart.notNull(this.future._mayComplete);
|
|
}
|
|
}
|
|
return _Completer;
|
|
});
|
|
let _Completer = _Completer$(dynamic);
|
|
let _AsyncCompleter$ = dart.generic(function(T) {
|
|
class _AsyncCompleter extends _Completer$(T) {
|
|
complete(value) {
|
|
if (value === void 0)
|
|
value = null;
|
|
if (!dart.notNull(this.future._mayComplete))
|
|
throw new core.StateError("Future already completed");
|
|
this.future._asyncComplete(value);
|
|
}
|
|
_completeError(error, stackTrace) {
|
|
this.future._asyncCompleteError(error, stackTrace);
|
|
}
|
|
}
|
|
return _AsyncCompleter;
|
|
});
|
|
let _AsyncCompleter = _AsyncCompleter$(dynamic);
|
|
let _SyncCompleter$ = dart.generic(function(T) {
|
|
class _SyncCompleter extends _Completer$(T) {
|
|
complete(value) {
|
|
if (value === void 0)
|
|
value = null;
|
|
if (!dart.notNull(this.future._mayComplete))
|
|
throw new core.StateError("Future already completed");
|
|
this.future._complete(value);
|
|
}
|
|
_completeError(error, stackTrace) {
|
|
this.future._completeError(error, stackTrace);
|
|
}
|
|
}
|
|
return _SyncCompleter;
|
|
});
|
|
let _SyncCompleter = _SyncCompleter$(dynamic);
|
|
class _FutureListener extends dart.Object {
|
|
_FutureListener$then(result, onValue, errorCallback) {
|
|
this.result = result;
|
|
this.callback = onValue;
|
|
this.errorCallback = errorCallback;
|
|
this.state = errorCallback === null ? STATE_THEN : STATE_THEN_ONERROR;
|
|
this._nextListener = null;
|
|
}
|
|
_FutureListener$catchError(result, errorCallback, test) {
|
|
this.result = result;
|
|
this.errorCallback = errorCallback;
|
|
this.callback = test;
|
|
this.state = test === null ? STATE_CATCHERROR : STATE_CATCHERROR_TEST;
|
|
this._nextListener = null;
|
|
}
|
|
_FutureListener$whenComplete(result, onComplete) {
|
|
this.result = result;
|
|
this.callback = onComplete;
|
|
this.errorCallback = null;
|
|
this.state = STATE_WHENCOMPLETE;
|
|
this._nextListener = null;
|
|
}
|
|
_FutureListener$chain(result) {
|
|
this.result = result;
|
|
this.callback = null;
|
|
this.errorCallback = null;
|
|
this.state = STATE_CHAIN;
|
|
this._nextListener = null;
|
|
}
|
|
get _zone() {
|
|
return this.result._zone;
|
|
}
|
|
get handlesValue() {
|
|
return (this.state & MASK_VALUE) !== 0;
|
|
}
|
|
get handlesError() {
|
|
return (this.state & MASK_ERROR) !== 0;
|
|
}
|
|
get hasErrorTest() {
|
|
return this.state === STATE_CATCHERROR_TEST;
|
|
}
|
|
get handlesComplete() {
|
|
return this.state === STATE_WHENCOMPLETE;
|
|
}
|
|
get _onValue() {
|
|
dart.assert(this.handlesValue);
|
|
return dart.as(this.callback, _FutureOnValue);
|
|
}
|
|
get _onError() {
|
|
return this.errorCallback;
|
|
}
|
|
get _errorTest() {
|
|
dart.assert(this.hasErrorTest);
|
|
return dart.as(this.callback, _FutureErrorTest);
|
|
}
|
|
get _whenCompleteAction() {
|
|
dart.assert(this.handlesComplete);
|
|
return dart.as(this.callback, _FutureAction);
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(_FutureListener, 'then');
|
|
dart.defineNamedConstructor(_FutureListener, 'catchError');
|
|
dart.defineNamedConstructor(_FutureListener, 'whenComplete');
|
|
dart.defineNamedConstructor(_FutureListener, 'chain');
|
|
_FutureListener.MASK_VALUE = 1;
|
|
_FutureListener.MASK_ERROR = 2;
|
|
_FutureListener.MASK_TEST_ERROR = 4;
|
|
_FutureListener.MASK_WHENCOMPLETE = 8;
|
|
_FutureListener.STATE_CHAIN = 0;
|
|
_FutureListener.STATE_THEN = MASK_VALUE;
|
|
_FutureListener.STATE_THEN_ONERROR = MASK_VALUE | MASK_ERROR;
|
|
_FutureListener.STATE_CATCHERROR = MASK_ERROR;
|
|
_FutureListener.STATE_CATCHERROR_TEST = MASK_ERROR | MASK_TEST_ERROR;
|
|
_FutureListener.STATE_WHENCOMPLETE = MASK_WHENCOMPLETE;
|
|
let _Future$ = dart.generic(function(T) {
|
|
class _Future extends dart.Object {
|
|
_Future() {
|
|
this._zone = Zone.current;
|
|
this._state = _INCOMPLETE;
|
|
this._resultOrListeners = null;
|
|
}
|
|
_Future$immediate(value) {
|
|
this._zone = Zone.current;
|
|
this._state = _INCOMPLETE;
|
|
this._resultOrListeners = null;
|
|
this._asyncComplete(value);
|
|
}
|
|
_Future$immediateError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
this._zone = Zone.current;
|
|
this._state = _INCOMPLETE;
|
|
this._resultOrListeners = null;
|
|
this._asyncCompleteError(error, stackTrace);
|
|
}
|
|
get _mayComplete() {
|
|
return this._state === _INCOMPLETE;
|
|
}
|
|
get _isChained() {
|
|
return this._state === _CHAINED;
|
|
}
|
|
get _isComplete() {
|
|
return this._state >= _VALUE;
|
|
}
|
|
get _hasValue() {
|
|
return this._state === _VALUE;
|
|
}
|
|
get _hasError() {
|
|
return this._state === _ERROR;
|
|
}
|
|
set _isChained(value) {
|
|
if (value) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
this._state = _CHAINED;
|
|
} else {
|
|
dart.assert(this._isChained);
|
|
this._state = _INCOMPLETE;
|
|
}
|
|
}
|
|
then(f, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let result = new _Future();
|
|
if (!dart.notNull(core.identical(result._zone, _ROOT_ZONE))) {
|
|
f = result._zone.registerUnaryCallback(dart.as(f, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
if (onError !== null) {
|
|
onError = _registerErrorHandler(onError, result._zone);
|
|
}
|
|
}
|
|
this._addListener(new _FutureListener.then(result, f, onError));
|
|
return result;
|
|
}
|
|
catchError(onError, opt$) {
|
|
let test = opt$.test === void 0 ? null : opt$.test;
|
|
let result = new _Future();
|
|
if (!dart.notNull(core.identical(result._zone, _ROOT_ZONE))) {
|
|
onError = _registerErrorHandler(onError, result._zone);
|
|
if (test !== null)
|
|
test = dart.as(result._zone.registerUnaryCallback(test), dart.throw_("Unimplemented type (dynamic) → bool"));
|
|
}
|
|
this._addListener(new _FutureListener.catchError(result, onError, test));
|
|
return result;
|
|
}
|
|
whenComplete(action) {
|
|
let result = new _Future();
|
|
if (!dart.notNull(core.identical(result._zone, _ROOT_ZONE))) {
|
|
action = result._zone.registerCallback(action);
|
|
}
|
|
this._addListener(new _FutureListener.whenComplete(result, action));
|
|
return dart.as(result, Future$(T));
|
|
}
|
|
asStream() {
|
|
return dart.as(new Stream.fromFuture(this), Stream$(T));
|
|
}
|
|
_markPendingCompletion() {
|
|
if (!dart.notNull(this._mayComplete))
|
|
throw new core.StateError("Future already completed");
|
|
this._state = _PENDING_COMPLETE;
|
|
}
|
|
get _value() {
|
|
dart.assert(dart.notNull(this._isComplete) && dart.notNull(this._hasValue));
|
|
return dart.as(this._resultOrListeners, T);
|
|
}
|
|
get _error() {
|
|
dart.assert(dart.notNull(this._isComplete) && dart.notNull(this._hasError));
|
|
return dart.as(this._resultOrListeners, AsyncError);
|
|
}
|
|
_setValue(value) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
this._state = _VALUE;
|
|
this._resultOrListeners = value;
|
|
}
|
|
_setErrorObject(error) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
this._state = _ERROR;
|
|
this._resultOrListeners = error;
|
|
}
|
|
_setError(error, stackTrace) {
|
|
this._setErrorObject(new AsyncError(error, stackTrace));
|
|
}
|
|
_addListener(listener) {
|
|
dart.assert(listener._nextListener === null);
|
|
if (this._isComplete) {
|
|
this._zone.scheduleMicrotask((() => {
|
|
_propagateToListeners(this, listener);
|
|
}).bind(this));
|
|
} else {
|
|
listener._nextListener = dart.as(this._resultOrListeners, _FutureListener);
|
|
this._resultOrListeners = listener;
|
|
}
|
|
}
|
|
_removeListeners() {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
let current = dart.as(this._resultOrListeners, _FutureListener);
|
|
this._resultOrListeners = null;
|
|
let prev = null;
|
|
while (current !== null) {
|
|
let next = current._nextListener;
|
|
current._nextListener = prev;
|
|
prev = current;
|
|
current = next;
|
|
}
|
|
return prev;
|
|
}
|
|
static _chainForeignFuture(source, target) {
|
|
dart.assert(!dart.notNull(target._isComplete));
|
|
dart.assert(!dart.is(source, _Future));
|
|
target._isChained = true;
|
|
source.then(((value) => {
|
|
dart.assert(target._isChained);
|
|
target._completeWithValue(value);
|
|
}).bind(this), {onError: ((error, stackTrace) => {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
dart.assert(target._isChained);
|
|
target._completeError(error, dart.as(stackTrace, core.StackTrace));
|
|
}).bind(this)});
|
|
}
|
|
static _chainCoreFuture(source, target) {
|
|
dart.assert(!dart.notNull(target._isComplete));
|
|
dart.assert(dart.is(source, _Future));
|
|
target._isChained = true;
|
|
let listener = new _FutureListener.chain(target);
|
|
if (source._isComplete) {
|
|
_propagateToListeners(source, listener);
|
|
} else {
|
|
source._addListener(listener);
|
|
}
|
|
}
|
|
_complete(value) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
if (dart.is(value, Future)) {
|
|
if (dart.is(value, _Future)) {
|
|
_chainCoreFuture(dart.as(value, _Future), this);
|
|
} else {
|
|
_chainForeignFuture(dart.as(value, Future), this);
|
|
}
|
|
} else {
|
|
let listeners = this._removeListeners();
|
|
this._setValue(dart.as(value, T));
|
|
_propagateToListeners(this, listeners);
|
|
}
|
|
}
|
|
_completeWithValue(value) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
dart.assert(!dart.is(value, Future));
|
|
let listeners = this._removeListeners();
|
|
this._setValue(dart.as(value, T));
|
|
_propagateToListeners(this, listeners);
|
|
}
|
|
_completeError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
let listeners = this._removeListeners();
|
|
this._setError(error, stackTrace);
|
|
_propagateToListeners(this, listeners);
|
|
}
|
|
_asyncComplete(value) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
if (value === null) {
|
|
} else if (dart.is(value, Future)) {
|
|
let typedFuture = dart.as(value, Future$(T));
|
|
if (dart.is(typedFuture, _Future)) {
|
|
let coreFuture = dart.as(typedFuture, _Future$(T));
|
|
if (dart.notNull(coreFuture._isComplete) && dart.notNull(coreFuture._hasError)) {
|
|
this._markPendingCompletion();
|
|
this._zone.scheduleMicrotask((() => {
|
|
_chainCoreFuture(coreFuture, this);
|
|
}).bind(this));
|
|
} else {
|
|
_chainCoreFuture(coreFuture, this);
|
|
}
|
|
} else {
|
|
_chainForeignFuture(typedFuture, this);
|
|
}
|
|
return;
|
|
} else {
|
|
let typedValue = dart.as(value, T);
|
|
}
|
|
this._markPendingCompletion();
|
|
this._zone.scheduleMicrotask((() => {
|
|
this._completeWithValue(value);
|
|
}).bind(this));
|
|
}
|
|
_asyncCompleteError(error, stackTrace) {
|
|
dart.assert(!dart.notNull(this._isComplete));
|
|
this._markPendingCompletion();
|
|
this._zone.scheduleMicrotask((() => {
|
|
this._completeError(error, stackTrace);
|
|
}).bind(this));
|
|
}
|
|
static _propagateToListeners(source, listeners) {
|
|
while (true) {
|
|
dart.assert(source._isComplete);
|
|
let hasError = source._hasError;
|
|
if (listeners === null) {
|
|
if (hasError) {
|
|
let asyncError = source._error;
|
|
source._zone.handleUncaughtError(asyncError.error, asyncError.stackTrace);
|
|
}
|
|
return;
|
|
}
|
|
while (listeners._nextListener !== null) {
|
|
let listener = listeners;
|
|
listeners = listener._nextListener;
|
|
listener._nextListener = null;
|
|
_propagateToListeners(source, listener);
|
|
}
|
|
let listener = listeners;
|
|
let listenerHasValue = true;
|
|
let sourceValue = hasError ? null : source._value;
|
|
let listenerValueOrError = sourceValue;
|
|
let isPropagationAborted = false;
|
|
if (dart.notNull(hasError) || dart.notNull(dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete))) {
|
|
let zone = listener._zone;
|
|
if (dart.notNull(hasError) && dart.notNull(!dart.notNull(source._zone.inSameErrorZone(zone)))) {
|
|
let asyncError = source._error;
|
|
source._zone.handleUncaughtError(asyncError.error, asyncError.stackTrace);
|
|
return;
|
|
}
|
|
let oldZone = null;
|
|
if (!dart.notNull(core.identical(Zone.current, zone))) {
|
|
oldZone = Zone._enter(zone);
|
|
}
|
|
// Function handleValueCallback: () → bool
|
|
function handleValueCallback() {
|
|
try {
|
|
listenerValueOrError = zone.runUnary(listener._onValue, sourceValue);
|
|
return true;
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
listenerValueOrError = new AsyncError(e, s);
|
|
return false;
|
|
}
|
|
|
|
}
|
|
// Function handleError: () → void
|
|
function handleError() {
|
|
let asyncError = source._error;
|
|
let matchesTest = true;
|
|
if (listener.hasErrorTest) {
|
|
let test = listener._errorTest;
|
|
try {
|
|
matchesTest = dart.as(zone.runUnary(test, asyncError.error), core.bool);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
|
|
listenerHasValue = false;
|
|
return;
|
|
}
|
|
|
|
}
|
|
let errorCallback = listener._onError;
|
|
if (dart.notNull(matchesTest) && dart.notNull(errorCallback !== null)) {
|
|
try {
|
|
if (dart.is(errorCallback, ZoneBinaryCallback)) {
|
|
listenerValueOrError = zone.runBinary(errorCallback, asyncError.error, asyncError.stackTrace);
|
|
} else {
|
|
listenerValueOrError = zone.runUnary(dart.as(errorCallback, dart.throw_("Unimplemented type (dynamic) → dynamic")), asyncError.error);
|
|
}
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
listenerValueOrError = core.identical(asyncError.error, e) ? asyncError : new AsyncError(e, s);
|
|
listenerHasValue = false;
|
|
return;
|
|
}
|
|
|
|
listenerHasValue = true;
|
|
} else {
|
|
listenerValueOrError = asyncError;
|
|
listenerHasValue = false;
|
|
}
|
|
}
|
|
// Function handleWhenCompleteCallback: () → void
|
|
function handleWhenCompleteCallback() {
|
|
let completeResult = null;
|
|
try {
|
|
completeResult = zone.run(listener._whenCompleteAction);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
if (dart.notNull(hasError) && dart.notNull(core.identical(source._error.error, e))) {
|
|
listenerValueOrError = source._error;
|
|
} else {
|
|
listenerValueOrError = new AsyncError(e, s);
|
|
}
|
|
listenerHasValue = false;
|
|
return;
|
|
}
|
|
|
|
if (dart.is(completeResult, Future)) {
|
|
let result = listener.result;
|
|
result._isChained = true;
|
|
isPropagationAborted = true;
|
|
dart.dinvoke(completeResult, 'then', (ignored) => {
|
|
_propagateToListeners(source, new _FutureListener.chain(result));
|
|
}, {
|
|
onError: (error, stackTrace) => {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
if (!dart.is(completeResult, _Future)) {
|
|
completeResult = new _Future();
|
|
dart.dinvoke(completeResult, '_setError', error, stackTrace);
|
|
}
|
|
_propagateToListeners(dart.as(completeResult, _Future), new _FutureListener.chain(result));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (!dart.notNull(hasError)) {
|
|
if (listener.handlesValue) {
|
|
listenerHasValue = handleValueCallback();
|
|
}
|
|
} else {
|
|
handleError();
|
|
}
|
|
if (listener.handlesComplete) {
|
|
handleWhenCompleteCallback();
|
|
}
|
|
if (oldZone !== null)
|
|
Zone._leave(oldZone);
|
|
if (isPropagationAborted)
|
|
return;
|
|
if (dart.notNull(dart.notNull(listenerHasValue) && dart.notNull(!dart.notNull(core.identical(sourceValue, listenerValueOrError)))) && dart.notNull(dart.is(listenerValueOrError, Future))) {
|
|
let chainSource = dart.as(listenerValueOrError, Future);
|
|
let result = listener.result;
|
|
if (dart.is(chainSource, _Future)) {
|
|
if (chainSource._isComplete) {
|
|
result._isChained = true;
|
|
source = chainSource;
|
|
listeners = new _FutureListener.chain(result);
|
|
continue;
|
|
} else {
|
|
_chainCoreFuture(chainSource, result);
|
|
}
|
|
} else {
|
|
_chainForeignFuture(chainSource, result);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
let result = listener.result;
|
|
listeners = result._removeListeners();
|
|
if (listenerHasValue) {
|
|
result._setValue(listenerValueOrError);
|
|
} else {
|
|
let asyncError = dart.as(listenerValueOrError, AsyncError);
|
|
result._setErrorObject(asyncError);
|
|
}
|
|
source = result;
|
|
}
|
|
}
|
|
timeout(timeLimit, opt$) {
|
|
let onTimeout = opt$.onTimeout === void 0 ? null : opt$.onTimeout;
|
|
if (this._isComplete)
|
|
return new _Future.immediate(this);
|
|
let result = new _Future();
|
|
let timer = null;
|
|
if (onTimeout === null) {
|
|
timer = new Timer(timeLimit, (() => {
|
|
result._completeError(new TimeoutException("Future not completed", timeLimit));
|
|
}).bind(this));
|
|
} else {
|
|
let zone = Zone.current;
|
|
onTimeout = zone.registerCallback(onTimeout);
|
|
timer = new Timer(timeLimit, (() => {
|
|
try {
|
|
result._complete(zone.run(onTimeout));
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
result._completeError(e, s);
|
|
}
|
|
|
|
}).bind(this));
|
|
}
|
|
this.then(((v) => {
|
|
if (timer.isActive) {
|
|
timer.cancel();
|
|
result._completeWithValue(v);
|
|
}
|
|
}).bind(this), {onError: ((e, s) => {
|
|
if (timer.isActive) {
|
|
timer.cancel();
|
|
result._completeError(e, dart.as(s, core.StackTrace));
|
|
}
|
|
}).bind(this)});
|
|
return result;
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(_Future, 'immediate');
|
|
dart.defineNamedConstructor(_Future, 'immediateError');
|
|
_Future._INCOMPLETE = 0;
|
|
_Future._PENDING_COMPLETE = 1;
|
|
_Future._CHAINED = 2;
|
|
_Future._VALUE = 4;
|
|
_Future._ERROR = 8;
|
|
return _Future;
|
|
});
|
|
let _Future = _Future$(dynamic);
|
|
class _AsyncCallbackEntry extends dart.Object {
|
|
_AsyncCallbackEntry(callback) {
|
|
this.callback = callback;
|
|
this.next = null;
|
|
}
|
|
}
|
|
async._nextCallback = null;
|
|
async._lastCallback = null;
|
|
async._lastPriorityCallback = null;
|
|
async._isInCallbackLoop = false;
|
|
// Function _asyncRunCallbackLoop: () → void
|
|
function _asyncRunCallbackLoop() {
|
|
while (async._nextCallback !== null) {
|
|
async._lastPriorityCallback = null;
|
|
let entry = async._nextCallback;
|
|
async._nextCallback = entry.next;
|
|
if (async._nextCallback === null)
|
|
async._lastCallback = null;
|
|
entry.callback();
|
|
}
|
|
}
|
|
// Function _asyncRunCallback: () → void
|
|
function _asyncRunCallback() {
|
|
async._isInCallbackLoop = true;
|
|
try {
|
|
_asyncRunCallbackLoop();
|
|
} finally {
|
|
async._lastPriorityCallback = null;
|
|
async._isInCallbackLoop = false;
|
|
if (async._nextCallback !== null)
|
|
_AsyncRun._scheduleImmediate(_asyncRunCallback);
|
|
}
|
|
}
|
|
// Function _scheduleAsyncCallback: (dynamic) → void
|
|
function _scheduleAsyncCallback(callback) {
|
|
if (async._nextCallback === null) {
|
|
async._nextCallback = async._lastCallback = new _AsyncCallbackEntry(callback);
|
|
if (!dart.notNull(async._isInCallbackLoop)) {
|
|
_AsyncRun._scheduleImmediate(_asyncRunCallback);
|
|
}
|
|
} else {
|
|
let newEntry = new _AsyncCallbackEntry(callback);
|
|
async._lastCallback.next = newEntry;
|
|
async._lastCallback = newEntry;
|
|
}
|
|
}
|
|
// Function _schedulePriorityAsyncCallback: (dynamic) → void
|
|
function _schedulePriorityAsyncCallback(callback) {
|
|
let entry = new _AsyncCallbackEntry(callback);
|
|
if (async._nextCallback === null) {
|
|
_scheduleAsyncCallback(callback);
|
|
async._lastPriorityCallback = async._lastCallback;
|
|
} else if (async._lastPriorityCallback === null) {
|
|
entry.next = async._nextCallback;
|
|
async._nextCallback = async._lastPriorityCallback = entry;
|
|
} else {
|
|
entry.next = async._lastPriorityCallback.next;
|
|
async._lastPriorityCallback.next = entry;
|
|
async._lastPriorityCallback = entry;
|
|
if (entry.next === null) {
|
|
async._lastCallback = entry;
|
|
}
|
|
}
|
|
}
|
|
// Function scheduleMicrotask: (() → void) → void
|
|
function scheduleMicrotask(callback) {
|
|
if (core.identical(_ROOT_ZONE, Zone.current)) {
|
|
_rootScheduleMicrotask(null, null, dart.as(_ROOT_ZONE, Zone), callback);
|
|
return;
|
|
}
|
|
Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
|
|
}
|
|
class _AsyncRun extends dart.Object {
|
|
static _scheduleImmediate(callback) {
|
|
dart.dinvokef(scheduleImmediateClosure, callback);
|
|
}
|
|
static _initializeScheduleImmediate() {
|
|
dart.dinvokef(/* Unimplemented unknown name */requiresPreamble);
|
|
if (dart.dinvokef(/* Unimplemented unknown name */JS, '', 'self.scheduleImmediate') !== null) {
|
|
return _scheduleImmediateJsOverride;
|
|
}
|
|
if (dart.notNull(dart.dinvokef(/* Unimplemented unknown name */JS, '', 'self.MutationObserver') !== null) && dart.notNull(dart.dinvokef(/* Unimplemented unknown name */JS, '', 'self.document') !== null)) {
|
|
let div = dart.dinvokef(/* Unimplemented unknown name */JS, '', 'self.document.createElement("div")');
|
|
let span = dart.dinvokef(/* Unimplemented unknown name */JS, '', 'self.document.createElement("span")');
|
|
let storedCallback = null;
|
|
// Function internalCallback: (dynamic) → dynamic
|
|
function internalCallback(_) {
|
|
dart.dinvokef(/* Unimplemented unknown name */leaveJsAsync);
|
|
let f = storedCallback;
|
|
storedCallback = null;
|
|
dart.dinvokef(f);
|
|
}
|
|
;
|
|
let observer = dart.dinvokef(/* Unimplemented unknown name */JS, '', 'new self.MutationObserver(#)', dart.dinvokef(/* Unimplemented unknown name */convertDartClosureToJS, internalCallback, 1));
|
|
dart.dinvokef(/* Unimplemented unknown name */JS, '', '#.observe(#, { childList: true })', observer, div);
|
|
return (callback) => {
|
|
dart.assert(storedCallback === null);
|
|
dart.dinvokef(/* Unimplemented unknown name */enterJsAsync);
|
|
storedCallback = callback;
|
|
dart.dinvokef(/* Unimplemented unknown name */JS, '', '#.firstChild ? #.removeChild(#): #.appendChild(#)', div, div, span, div, span);
|
|
};
|
|
} else if (dart.dinvokef(/* Unimplemented unknown name */JS, '', 'self.setImmediate') !== null) {
|
|
return _scheduleImmediateWithSetImmediate;
|
|
}
|
|
return _scheduleImmediateWithTimer;
|
|
}
|
|
static _scheduleImmediateJsOverride(callback) {
|
|
// Function internalCallback: () → dynamic
|
|
function internalCallback() {
|
|
dart.dinvokef(/* Unimplemented unknown name */leaveJsAsync);
|
|
callback();
|
|
}
|
|
;
|
|
dart.dinvokef(/* Unimplemented unknown name */enterJsAsync);
|
|
dart.dinvokef(/* Unimplemented unknown name */JS, 'void', 'self.scheduleImmediate(#)', dart.dinvokef(/* Unimplemented unknown name */convertDartClosureToJS, internalCallback, 0));
|
|
}
|
|
static _scheduleImmediateWithSetImmediate(callback) {
|
|
// Function internalCallback: () → dynamic
|
|
function internalCallback() {
|
|
dart.dinvokef(/* Unimplemented unknown name */leaveJsAsync);
|
|
callback();
|
|
}
|
|
;
|
|
dart.dinvokef(/* Unimplemented unknown name */enterJsAsync);
|
|
dart.dinvokef(/* Unimplemented unknown name */JS, 'void', 'self.setImmediate(#)', dart.dinvokef(/* Unimplemented unknown name */convertDartClosureToJS, internalCallback, 0));
|
|
}
|
|
static _scheduleImmediateWithTimer(callback) {
|
|
Timer._createTimer(core.Duration.ZERO, callback);
|
|
}
|
|
}
|
|
dart.defineLazyProperties(_AsyncRun, {
|
|
get scheduleImmediateClosure() {
|
|
return _initializeScheduleImmediate();
|
|
}
|
|
});
|
|
let Stream$ = dart.generic(function(T) {
|
|
class Stream extends dart.Object {
|
|
Stream() {
|
|
}
|
|
Stream$fromFuture(future) {
|
|
let controller = dart.as(new StreamController({sync: true}), _StreamController$(T));
|
|
future.then(((value) => {
|
|
controller._add(dart.as(value, T));
|
|
controller._closeUnchecked();
|
|
}).bind(this), {onError: ((error, stackTrace) => {
|
|
controller._addError(error, dart.as(stackTrace, core.StackTrace));
|
|
controller._closeUnchecked();
|
|
}).bind(this)});
|
|
return controller.stream;
|
|
}
|
|
Stream$fromIterable(data) {
|
|
return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
|
|
}
|
|
Stream$periodic(period, computation) {
|
|
if (computation === void 0)
|
|
computation = null;
|
|
if (computation === null)
|
|
computation = dart.as((i) => null, dart.throw_("Unimplemented type (int) → T"));
|
|
let timer = null;
|
|
let computationCount = 0;
|
|
let controller = null;
|
|
let watch = new core.Stopwatch();
|
|
// Function sendEvent: () → void
|
|
function sendEvent() {
|
|
watch.reset();
|
|
let data = computation(computationCount++);
|
|
controller.add(data);
|
|
}
|
|
// Function startPeriodicTimer: () → void
|
|
function startPeriodicTimer() {
|
|
dart.assert(timer === null);
|
|
timer = new Timer.periodic(period, (timer) => {
|
|
sendEvent();
|
|
});
|
|
}
|
|
controller = new StreamController({sync: true, onListen: (() => {
|
|
watch.start();
|
|
startPeriodicTimer();
|
|
}).bind(this), onPause: (() => {
|
|
timer.cancel();
|
|
timer = null;
|
|
watch.stop();
|
|
}).bind(this), onResume: (() => {
|
|
dart.assert(timer === null);
|
|
let elapsed = watch.elapsed;
|
|
watch.start();
|
|
timer = new Timer(period['-'](elapsed), () => {
|
|
timer = null;
|
|
startPeriodicTimer();
|
|
sendEvent();
|
|
});
|
|
}).bind(this), onCancel: (() => {
|
|
if (timer !== null)
|
|
timer.cancel();
|
|
timer = null;
|
|
}).bind(this)});
|
|
return controller.stream;
|
|
}
|
|
Stream$eventTransformed(source, mapSink) {
|
|
return dart.as(new _BoundSinkStream(source, mapSink), Stream$(T));
|
|
}
|
|
get isBroadcast() {
|
|
return false;
|
|
}
|
|
asBroadcastStream(opt$) {
|
|
let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
|
|
let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
|
|
return new _AsBroadcastStream(this, onListen, onCancel);
|
|
}
|
|
where(test) {
|
|
return new _WhereStream(this, test);
|
|
}
|
|
map(convert) {
|
|
return new _MapStream(this, convert);
|
|
}
|
|
asyncMap(convert) {
|
|
let controller = null;
|
|
let subscription = null;
|
|
// Function onListen: () → void
|
|
function onListen() {
|
|
let add = controller.add;
|
|
dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
|
|
let eventSink = controller;
|
|
let addError = eventSink._addError;
|
|
subscription = this.listen(((event) => {
|
|
let newValue = null;
|
|
try {
|
|
newValue = convert(event);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
controller.addError(e, s);
|
|
return;
|
|
}
|
|
|
|
if (dart.is(newValue, Future)) {
|
|
subscription.pause();
|
|
dart.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
|
|
} else {
|
|
controller.add(newValue);
|
|
}
|
|
}).bind(this), {onError: dart.as(addError, core.Function), onDone: controller.close});
|
|
}
|
|
if (this.isBroadcast) {
|
|
controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
|
|
subscription.cancel();
|
|
}).bind(this), sync: true});
|
|
} else {
|
|
controller = new StreamController({onListen: onListen, onPause: (() => {
|
|
subscription.pause();
|
|
}).bind(this), onResume: (() => {
|
|
subscription.resume();
|
|
}).bind(this), onCancel: (() => {
|
|
subscription.cancel();
|
|
}).bind(this), sync: true});
|
|
}
|
|
return controller.stream;
|
|
}
|
|
asyncExpand(convert) {
|
|
let controller = null;
|
|
let subscription = null;
|
|
// Function onListen: () → void
|
|
function onListen() {
|
|
dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
|
|
let eventSink = controller;
|
|
subscription = this.listen(((event) => {
|
|
let newStream = null;
|
|
try {
|
|
newStream = convert(event);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
controller.addError(e, s);
|
|
return;
|
|
}
|
|
|
|
if (newStream !== null) {
|
|
subscription.pause();
|
|
controller.addStream(newStream).whenComplete(subscription.resume);
|
|
}
|
|
}).bind(this), {onError: dart.as(eventSink._addError, core.Function), onDone: controller.close});
|
|
}
|
|
if (this.isBroadcast) {
|
|
controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
|
|
subscription.cancel();
|
|
}).bind(this), sync: true});
|
|
} else {
|
|
controller = new StreamController({onListen: onListen, onPause: (() => {
|
|
subscription.pause();
|
|
}).bind(this), onResume: (() => {
|
|
subscription.resume();
|
|
}).bind(this), onCancel: (() => {
|
|
subscription.cancel();
|
|
}).bind(this), sync: true});
|
|
}
|
|
return controller.stream;
|
|
}
|
|
handleError(onError, opt$) {
|
|
let test = opt$.test === void 0 ? null : opt$.test;
|
|
return new _HandleErrorStream(this, onError, test);
|
|
}
|
|
expand(convert) {
|
|
return new _ExpandStream(this, convert);
|
|
}
|
|
pipe(streamConsumer) {
|
|
return streamConsumer.addStream(this).then(((_) => streamConsumer.close()).bind(this));
|
|
}
|
|
transform(streamTransformer) {
|
|
return streamTransformer.bind(this);
|
|
}
|
|
reduce(combine) {
|
|
let result = new _Future();
|
|
let seenFirst = false;
|
|
let value = null;
|
|
let subscription = null;
|
|
subscription = this.listen((element) => {
|
|
if (seenFirst) {
|
|
_runUserCode(() => combine(value, element), dart.as((newValue) => {
|
|
value = newValue;
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
} else {
|
|
value = element;
|
|
seenFirst = true;
|
|
}
|
|
}, {onError: result._completeError, onDone: (() => {
|
|
if (!dart.notNull(seenFirst)) {
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(result, e, s);
|
|
}
|
|
|
|
} else {
|
|
result._complete(value);
|
|
}
|
|
}).bind(this), cancelOnError: true});
|
|
return result;
|
|
}
|
|
fold(initialValue, combine) {
|
|
let result = new _Future();
|
|
let value = initialValue;
|
|
let subscription = null;
|
|
subscription = this.listen((element) => {
|
|
_runUserCode(() => combine(value, element), (newValue) => {
|
|
value = newValue;
|
|
}, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: ((e, st) => {
|
|
result._completeError(e, dart.as(st, core.StackTrace));
|
|
}).bind(this), onDone: (() => {
|
|
result._complete(value);
|
|
}).bind(this), cancelOnError: true});
|
|
return result;
|
|
}
|
|
join(separator) {
|
|
if (separator === void 0)
|
|
separator = "";
|
|
let result = new _Future();
|
|
let buffer = new core.StringBuffer();
|
|
let subscription = null;
|
|
let first = true;
|
|
subscription = this.listen(((element) => {
|
|
if (!dart.notNull(first)) {
|
|
buffer.write(separator);
|
|
}
|
|
first = false;
|
|
try {
|
|
buffer.write(element);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_cancelAndErrorWithReplacement(subscription, result, e, s);
|
|
}
|
|
|
|
}).bind(this), {onError: ((e) => {
|
|
result._completeError(e);
|
|
}).bind(this), onDone: (() => {
|
|
result._complete(buffer.toString());
|
|
}).bind(this), cancelOnError: true});
|
|
return result;
|
|
}
|
|
contains(needle) {
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((element) => {
|
|
_runUserCode(() => dart.equals(element, needle), dart.as((isMatch) => {
|
|
if (isMatch) {
|
|
_cancelAndValue(subscription, future, true);
|
|
}
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._complete(false);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
forEach(action) {
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((element) => {
|
|
_runUserCode(() => action(element), (_) => {
|
|
}, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._complete(null);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
every(test) {
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((element) => {
|
|
_runUserCode(() => test(element), dart.as((isMatch) => {
|
|
if (!dart.notNull(isMatch)) {
|
|
_cancelAndValue(subscription, future, false);
|
|
}
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._complete(true);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
any(test) {
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((element) => {
|
|
_runUserCode(() => test(element), dart.as((isMatch) => {
|
|
if (isMatch) {
|
|
_cancelAndValue(subscription, future, true);
|
|
}
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._complete(false);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
get length() {
|
|
let future = new _Future();
|
|
let count = 0;
|
|
this.listen((_) => {
|
|
count++;
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._complete(count);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
get isEmpty() {
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((_) => {
|
|
_cancelAndValue(subscription, future, false);
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._complete(true);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
toList() {
|
|
let result = new List.from([]);
|
|
let future = new _Future();
|
|
this.listen(((data) => {
|
|
result.add(data);
|
|
}).bind(this), {onError: future._completeError, onDone: (() => {
|
|
future._complete(result);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
toSet() {
|
|
let result = new core.Set();
|
|
let future = new _Future();
|
|
this.listen(((data) => {
|
|
result.add(data);
|
|
}).bind(this), {onError: future._completeError, onDone: (() => {
|
|
future._complete(result);
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
drain(futureValue) {
|
|
if (futureValue === void 0)
|
|
futureValue = null;
|
|
return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
|
|
}
|
|
take(count) {
|
|
return dart.as(new _TakeStream(this, count), Stream$(T));
|
|
}
|
|
takeWhile(test) {
|
|
return dart.as(new _TakeWhileStream(this, test), Stream$(T));
|
|
}
|
|
skip(count) {
|
|
return dart.as(new _SkipStream(this, count), Stream$(T));
|
|
}
|
|
skipWhile(test) {
|
|
return dart.as(new _SkipWhileStream(this, test), Stream$(T));
|
|
}
|
|
distinct(equals) {
|
|
if (equals === void 0)
|
|
equals = null;
|
|
return dart.as(new _DistinctStream(this, equals), Stream$(T));
|
|
}
|
|
get first() {
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((value) => {
|
|
_cancelAndValue(subscription, future, value);
|
|
}, {
|
|
onError: future._completeError,
|
|
onDone: () => {
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(future, e, s);
|
|
}
|
|
|
|
},
|
|
cancelOnError: true
|
|
});
|
|
return future;
|
|
}
|
|
get last() {
|
|
let future = new _Future();
|
|
let result = dart.as(null, T);
|
|
let foundResult = false;
|
|
let subscription = null;
|
|
subscription = this.listen((value) => {
|
|
foundResult = true;
|
|
result = value;
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
if (foundResult) {
|
|
future._complete(result);
|
|
return;
|
|
}
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(future, e, s);
|
|
}
|
|
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
get single() {
|
|
let future = new _Future();
|
|
let result = dart.as(null, T);
|
|
let foundResult = false;
|
|
let subscription = null;
|
|
subscription = this.listen((value) => {
|
|
if (foundResult) {
|
|
try {
|
|
throw _internal.IterableElementError.tooMany();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_cancelAndErrorWithReplacement(subscription, future, e, s);
|
|
}
|
|
|
|
return;
|
|
}
|
|
foundResult = true;
|
|
result = value;
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
if (foundResult) {
|
|
future._complete(result);
|
|
return;
|
|
}
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(future, e, s);
|
|
}
|
|
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
firstWhere(test, opt$) {
|
|
let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
subscription = this.listen((value) => {
|
|
_runUserCode(() => test(value), dart.as((isMatch) => {
|
|
if (isMatch) {
|
|
_cancelAndValue(subscription, future, value);
|
|
}
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
if (defaultValue !== null) {
|
|
_runUserCode(defaultValue, future._complete, future._completeError);
|
|
return;
|
|
}
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(future, e, s);
|
|
}
|
|
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
lastWhere(test, opt$) {
|
|
let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
|
|
let future = new _Future();
|
|
let result = dart.as(null, T);
|
|
let foundResult = false;
|
|
let subscription = null;
|
|
subscription = this.listen((value) => {
|
|
_runUserCode(() => true === test(value), dart.as((isMatch) => {
|
|
if (isMatch) {
|
|
foundResult = true;
|
|
result = value;
|
|
}
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
if (foundResult) {
|
|
future._complete(result);
|
|
return;
|
|
}
|
|
if (defaultValue !== null) {
|
|
_runUserCode(defaultValue, future._complete, future._completeError);
|
|
return;
|
|
}
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(future, e, s);
|
|
}
|
|
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
singleWhere(test) {
|
|
let future = new _Future();
|
|
let result = dart.as(null, T);
|
|
let foundResult = false;
|
|
let subscription = null;
|
|
subscription = this.listen((value) => {
|
|
_runUserCode(() => true === test(value), dart.as((isMatch) => {
|
|
if (isMatch) {
|
|
if (foundResult) {
|
|
try {
|
|
throw _internal.IterableElementError.tooMany();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_cancelAndErrorWithReplacement(subscription, future, e, s);
|
|
}
|
|
|
|
return;
|
|
}
|
|
foundResult = true;
|
|
result = value;
|
|
}
|
|
}, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
if (foundResult) {
|
|
future._complete(result);
|
|
return;
|
|
}
|
|
try {
|
|
throw _internal.IterableElementError.noElement();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_completeWithErrorCallback(future, e, s);
|
|
}
|
|
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
elementAt(index) {
|
|
if (dart.notNull(!(typeof index == number)) || dart.notNull(index < 0))
|
|
throw new core.ArgumentError(index);
|
|
let future = new _Future();
|
|
let subscription = null;
|
|
let elementIndex = 0;
|
|
subscription = this.listen((value) => {
|
|
if (index === elementIndex) {
|
|
_cancelAndValue(subscription, future, value);
|
|
return;
|
|
}
|
|
elementIndex = 1;
|
|
}, {onError: future._completeError, onDone: (() => {
|
|
future._completeError(new core.RangeError.index(index, this, "index", null, elementIndex));
|
|
}).bind(this), cancelOnError: true});
|
|
return future;
|
|
}
|
|
timeout(timeLimit, opt$) {
|
|
let onTimeout = opt$.onTimeout === void 0 ? null : opt$.onTimeout;
|
|
let controller = null;
|
|
let subscription = null;
|
|
let timer = null;
|
|
let zone = null;
|
|
let timeout = null;
|
|
// Function onData: (T) → void
|
|
function onData(event) {
|
|
timer.cancel();
|
|
controller.add(event);
|
|
timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
|
|
}
|
|
// Function onError: (dynamic, StackTrace) → void
|
|
function onError(error, stackTrace) {
|
|
timer.cancel();
|
|
dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
|
|
let eventSink = controller;
|
|
dart.dinvoke(eventSink, '_addError', error, stackTrace);
|
|
timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
|
|
}
|
|
// Function onDone: () → void
|
|
function onDone() {
|
|
timer.cancel();
|
|
controller.close();
|
|
}
|
|
// Function onListen: () → void
|
|
function onListen() {
|
|
zone = Zone.current;
|
|
if (onTimeout === null) {
|
|
timeout = (() => {
|
|
controller.addError(new TimeoutException("No stream event", timeLimit), null);
|
|
}).bind(this);
|
|
} else {
|
|
onTimeout = zone.registerUnaryCallback(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
let wrapper = new _ControllerEventSinkWrapper(null);
|
|
timeout = (() => {
|
|
wrapper._sink = controller;
|
|
zone.runUnaryGuarded(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")), wrapper);
|
|
wrapper._sink = null;
|
|
}).bind(this);
|
|
}
|
|
subscription = this.listen(onData, {onError: onError, onDone: onDone});
|
|
timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
|
|
}
|
|
// Function onCancel: () → Future<dynamic>
|
|
function onCancel() {
|
|
timer.cancel();
|
|
let result = subscription.cancel();
|
|
subscription = null;
|
|
return result;
|
|
}
|
|
controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, (() => {
|
|
timer.cancel();
|
|
subscription.pause();
|
|
}).bind(this), (() => {
|
|
subscription.resume();
|
|
timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
|
|
}).bind(this), onCancel);
|
|
return controller.stream;
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(Stream, 'fromFuture');
|
|
dart.defineNamedConstructor(Stream, 'fromIterable');
|
|
dart.defineNamedConstructor(Stream, 'periodic');
|
|
dart.defineNamedConstructor(Stream, 'eventTransformed');
|
|
return Stream;
|
|
});
|
|
let Stream = Stream$(dynamic);
|
|
let StreamSubscription$ = dart.generic(function(T) {
|
|
class StreamSubscription extends dart.Object {
|
|
}
|
|
return StreamSubscription;
|
|
});
|
|
let StreamSubscription = StreamSubscription$(dynamic);
|
|
let EventSink$ = dart.generic(function(T) {
|
|
class EventSink extends dart.Object {
|
|
}
|
|
return EventSink;
|
|
});
|
|
let EventSink = EventSink$(dynamic);
|
|
let StreamView$ = dart.generic(function(T) {
|
|
class StreamView extends Stream$(T) {
|
|
StreamView(_stream) {
|
|
this._stream = _stream;
|
|
super.Stream();
|
|
}
|
|
get isBroadcast() {
|
|
return this._stream.isBroadcast;
|
|
}
|
|
asBroadcastStream(opt$) {
|
|
let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
|
|
let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
|
|
return this._stream.asBroadcastStream({onListen: onListen, onCancel: onCancel});
|
|
}
|
|
listen(onData, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
|
|
return this._stream.listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
|
|
}
|
|
}
|
|
return StreamView;
|
|
});
|
|
let StreamView = StreamView$(dynamic);
|
|
let StreamConsumer$ = dart.generic(function(S) {
|
|
class StreamConsumer extends dart.Object {
|
|
}
|
|
return StreamConsumer;
|
|
});
|
|
let StreamConsumer = StreamConsumer$(dynamic);
|
|
let StreamSink$ = dart.generic(function(S) {
|
|
class StreamSink extends dart.Object {
|
|
}
|
|
return StreamSink;
|
|
});
|
|
let StreamSink = StreamSink$(dynamic);
|
|
let StreamTransformer$ = dart.generic(function(S, T) {
|
|
class StreamTransformer extends dart.Object {
|
|
StreamTransformer(transformer) {
|
|
return new _StreamSubscriptionTransformer(transformer);
|
|
}
|
|
StreamTransformer$fromHandlers(opt$) {
|
|
return new _StreamHandlerTransformer(opt$);
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
|
|
return StreamTransformer;
|
|
});
|
|
let StreamTransformer = StreamTransformer$(dynamic, dynamic);
|
|
let StreamIterator$ = dart.generic(function(T) {
|
|
class StreamIterator extends dart.Object {
|
|
StreamIterator(stream) {
|
|
return new _StreamIteratorImpl(stream);
|
|
}
|
|
}
|
|
return StreamIterator;
|
|
});
|
|
let StreamIterator = StreamIterator$(dynamic);
|
|
let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
|
|
class _ControllerEventSinkWrapper extends dart.Object {
|
|
_ControllerEventSinkWrapper(_sink) {
|
|
this._sink = _sink;
|
|
}
|
|
add(data) {
|
|
this._sink.add(data);
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
this._sink.addError(error, stackTrace);
|
|
}
|
|
close() {
|
|
this._sink.close();
|
|
}
|
|
}
|
|
return _ControllerEventSinkWrapper;
|
|
});
|
|
let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$(dynamic);
|
|
let StreamController$ = dart.generic(function(T) {
|
|
class StreamController extends dart.Object {
|
|
StreamController(opt$) {
|
|
let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
|
|
let onPause = opt$.onPause === void 0 ? null : opt$.onPause;
|
|
let onResume = opt$.onResume === void 0 ? null : opt$.onResume;
|
|
let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
|
|
let sync = opt$.sync === void 0 ? false : opt$.sync;
|
|
if (dart.notNull(dart.notNull(dart.notNull(onListen === null) && dart.notNull(onPause === null)) && dart.notNull(onResume === null)) && dart.notNull(onCancel === null)) {
|
|
return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
|
|
}
|
|
return sync ? new _SyncStreamController(onListen, onPause, onResume, onCancel) : new _AsyncStreamController(onListen, onPause, onResume, onCancel);
|
|
}
|
|
StreamController$broadcast(opt$) {
|
|
let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
|
|
let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
|
|
let sync = opt$.sync === void 0 ? false : opt$.sync;
|
|
return sync ? new _SyncBroadcastStreamController(onListen, onCancel) : new _AsyncBroadcastStreamController(onListen, onCancel);
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(StreamController, 'broadcast');
|
|
return StreamController;
|
|
});
|
|
let StreamController = StreamController$(dynamic);
|
|
let _StreamControllerLifecycle$ = dart.generic(function(T) {
|
|
class _StreamControllerLifecycle extends dart.Object {
|
|
_recordPause(subscription) {}
|
|
_recordResume(subscription) {}
|
|
_recordCancel(subscription) {
|
|
return null;
|
|
}
|
|
}
|
|
return _StreamControllerLifecycle;
|
|
});
|
|
let _StreamControllerLifecycle = _StreamControllerLifecycle$(dynamic);
|
|
let _StreamController$ = dart.generic(function(T) {
|
|
class _StreamController extends dart.Object {
|
|
_StreamController() {
|
|
this._varData = null;
|
|
this._state = _STATE_INITIAL;
|
|
this._doneFuture = null;
|
|
}
|
|
get stream() {
|
|
return dart.as(new _ControllerStream(this), Stream$(T));
|
|
}
|
|
get sink() {
|
|
return new _StreamSinkWrapper(this);
|
|
}
|
|
get _isCanceled() {
|
|
return (this._state & _STATE_CANCELED) !== 0;
|
|
}
|
|
get hasListener() {
|
|
return (this._state & _STATE_SUBSCRIBED) !== 0;
|
|
}
|
|
get _isInitialState() {
|
|
return (this._state & _STATE_SUBSCRIPTION_MASK) === _STATE_INITIAL;
|
|
}
|
|
get isClosed() {
|
|
return (this._state & _STATE_CLOSED) !== 0;
|
|
}
|
|
get isPaused() {
|
|
return this.hasListener ? this._subscription._isInputPaused : !dart.notNull(this._isCanceled);
|
|
}
|
|
get _isAddingStream() {
|
|
return (this._state & _STATE_ADDSTREAM) !== 0;
|
|
}
|
|
get _mayAddEvent() {
|
|
return this._state < _STATE_CLOSED;
|
|
}
|
|
get _pendingEvents() {
|
|
dart.assert(this._isInitialState);
|
|
if (!dart.notNull(this._isAddingStream)) {
|
|
return dart.as(this._varData, _PendingEvents);
|
|
}
|
|
let state = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
return dart.as(state.varData, _PendingEvents);
|
|
}
|
|
_ensurePendingEvents() {
|
|
dart.assert(this._isInitialState);
|
|
if (!dart.notNull(this._isAddingStream)) {
|
|
if (this._varData === null)
|
|
this._varData = new _StreamImplEvents();
|
|
return dart.as(this._varData, _StreamImplEvents);
|
|
}
|
|
let state = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
if (state.varData === null)
|
|
state.varData = new _StreamImplEvents();
|
|
return dart.as(state.varData, _StreamImplEvents);
|
|
}
|
|
get _subscription() {
|
|
dart.assert(this.hasListener);
|
|
if (this._isAddingStream) {
|
|
let addState = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
return dart.as(addState.varData, _ControllerSubscription);
|
|
}
|
|
return dart.as(this._varData, _ControllerSubscription);
|
|
}
|
|
_badEventState() {
|
|
if (this.isClosed) {
|
|
return new core.StateError("Cannot add event after closing");
|
|
}
|
|
dart.assert(this._isAddingStream);
|
|
return new core.StateError("Cannot add event while adding a stream");
|
|
}
|
|
addStream(source, opt$) {
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? true : opt$.cancelOnError;
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._badEventState();
|
|
if (this._isCanceled)
|
|
return new _Future.immediate(null);
|
|
let addState = new _StreamControllerAddStreamState(this, this._varData, source, cancelOnError);
|
|
this._varData = addState;
|
|
this._state = _STATE_ADDSTREAM;
|
|
return addState.addStreamFuture;
|
|
}
|
|
get done() {
|
|
return this._ensureDoneFuture();
|
|
}
|
|
_ensureDoneFuture() {
|
|
if (this._doneFuture === null) {
|
|
this._doneFuture = this._isCanceled ? Future._nullFuture : new _Future();
|
|
}
|
|
return this._doneFuture;
|
|
}
|
|
add(value) {
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._badEventState();
|
|
this._add(value);
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
error = _nonNullError(error);
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._badEventState();
|
|
let replacement = Zone.current.errorCallback(error, stackTrace);
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
this._addError(error, stackTrace);
|
|
}
|
|
close() {
|
|
if (this.isClosed) {
|
|
return this._ensureDoneFuture();
|
|
}
|
|
if (!dart.notNull(this._mayAddEvent))
|
|
throw this._badEventState();
|
|
this._closeUnchecked();
|
|
return this._ensureDoneFuture();
|
|
}
|
|
_closeUnchecked() {
|
|
this._state = _STATE_CLOSED;
|
|
if (this.hasListener) {
|
|
this._sendDone();
|
|
} else if (this._isInitialState) {
|
|
this._ensurePendingEvents().add(new _DelayedDone());
|
|
}
|
|
}
|
|
_add(value) {
|
|
if (this.hasListener) {
|
|
this._sendData(value);
|
|
} else if (this._isInitialState) {
|
|
this._ensurePendingEvents().add(new _DelayedData(value));
|
|
}
|
|
}
|
|
_addError(error, stackTrace) {
|
|
if (this.hasListener) {
|
|
this._sendError(error, stackTrace);
|
|
} else if (this._isInitialState) {
|
|
this._ensurePendingEvents().add(new _DelayedError(error, stackTrace));
|
|
}
|
|
}
|
|
_close() {
|
|
dart.assert(this._isAddingStream);
|
|
let addState = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
this._varData = addState.varData;
|
|
this._state = ~_STATE_ADDSTREAM;
|
|
addState.complete();
|
|
}
|
|
_subscribe(onData, onError, onDone, cancelOnError) {
|
|
if (!dart.notNull(this._isInitialState)) {
|
|
throw new core.StateError("Stream has already been listened to.");
|
|
}
|
|
let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
|
|
let pendingEvents = this._pendingEvents;
|
|
this._state = _STATE_SUBSCRIBED;
|
|
if (this._isAddingStream) {
|
|
let addState = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
addState.varData = subscription;
|
|
addState.resume();
|
|
} else {
|
|
this._varData = subscription;
|
|
}
|
|
subscription._setPendingEvents(pendingEvents);
|
|
subscription._guardCallback((() => {
|
|
_runGuarded(this._onListen);
|
|
}).bind(this));
|
|
return dart.as(subscription, StreamSubscription$(T));
|
|
}
|
|
_recordCancel(subscription) {
|
|
let result = null;
|
|
if (this._isAddingStream) {
|
|
let addState = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
result = addState.cancel();
|
|
}
|
|
this._varData = null;
|
|
this._state = this._state & ~(_STATE_SUBSCRIBED | _STATE_ADDSTREAM) | _STATE_CANCELED;
|
|
if (this._onCancel !== null) {
|
|
if (result === null) {
|
|
try {
|
|
result = dart.as(this._onCancel(), Future);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
result = ((_) => {
|
|
_._asyncCompleteError(e, s);
|
|
return _;
|
|
}).bind(this)(new _Future());
|
|
}
|
|
|
|
} else {
|
|
result = result.whenComplete(this._onCancel);
|
|
}
|
|
}
|
|
// Function complete: () → void
|
|
function complete() {
|
|
if (dart.notNull(this._doneFuture !== null) && dart.notNull(this._doneFuture._mayComplete)) {
|
|
this._doneFuture._asyncComplete(null);
|
|
}
|
|
}
|
|
if (result !== null) {
|
|
result = result.whenComplete(complete);
|
|
} else {
|
|
complete();
|
|
}
|
|
return result;
|
|
}
|
|
_recordPause(subscription) {
|
|
if (this._isAddingStream) {
|
|
let addState = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
addState.pause();
|
|
}
|
|
_runGuarded(this._onPause);
|
|
}
|
|
_recordResume(subscription) {
|
|
if (this._isAddingStream) {
|
|
let addState = dart.as(this._varData, _StreamControllerAddStreamState);
|
|
addState.resume();
|
|
}
|
|
_runGuarded(this._onResume);
|
|
}
|
|
}
|
|
_StreamController._STATE_INITIAL = 0;
|
|
_StreamController._STATE_SUBSCRIBED = 1;
|
|
_StreamController._STATE_CANCELED = 2;
|
|
_StreamController._STATE_SUBSCRIPTION_MASK = 3;
|
|
_StreamController._STATE_CLOSED = 4;
|
|
_StreamController._STATE_ADDSTREAM = 8;
|
|
return _StreamController;
|
|
});
|
|
let _StreamController = _StreamController$(dynamic);
|
|
let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
|
|
class _SyncStreamControllerDispatch extends dart.Object {
|
|
_sendData(data) {
|
|
this._subscription._add(data);
|
|
}
|
|
_sendError(error, stackTrace) {
|
|
this._subscription._addError(error, stackTrace);
|
|
}
|
|
_sendDone() {
|
|
this._subscription._close();
|
|
}
|
|
}
|
|
return _SyncStreamControllerDispatch;
|
|
});
|
|
let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$(dynamic);
|
|
let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
|
|
class _AsyncStreamControllerDispatch extends dart.Object {
|
|
_sendData(data) {
|
|
this._subscription._addPending(new _DelayedData(data));
|
|
}
|
|
_sendError(error, stackTrace) {
|
|
this._subscription._addPending(new _DelayedError(error, stackTrace));
|
|
}
|
|
_sendDone() {
|
|
this._subscription._addPending(new _DelayedDone());
|
|
}
|
|
}
|
|
return _AsyncStreamControllerDispatch;
|
|
});
|
|
let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$(dynamic);
|
|
let _AsyncStreamController$ = dart.generic(function(T) {
|
|
class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
|
|
_AsyncStreamController(_onListen, _onPause, _onResume, _onCancel) {
|
|
this._onListen = _onListen;
|
|
this._onPause = _onPause;
|
|
this._onResume = _onResume;
|
|
this._onCancel = _onCancel;
|
|
super._StreamController();
|
|
}
|
|
}
|
|
return _AsyncStreamController;
|
|
});
|
|
let _AsyncStreamController = _AsyncStreamController$(dynamic);
|
|
let _SyncStreamController$ = dart.generic(function(T) {
|
|
class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
|
|
_SyncStreamController(_onListen, _onPause, _onResume, _onCancel) {
|
|
this._onListen = _onListen;
|
|
this._onPause = _onPause;
|
|
this._onResume = _onResume;
|
|
this._onCancel = _onCancel;
|
|
super._StreamController();
|
|
}
|
|
}
|
|
return _SyncStreamController;
|
|
});
|
|
let _SyncStreamController = _SyncStreamController$(dynamic);
|
|
class _NoCallbacks extends dart.Object {
|
|
get _onListen() {
|
|
return null;
|
|
}
|
|
get _onPause() {
|
|
return null;
|
|
}
|
|
get _onResume() {
|
|
return null;
|
|
}
|
|
get _onCancel() {
|
|
return null;
|
|
}
|
|
}
|
|
class _NoCallbackAsyncStreamController extends dart.mixin(_AsyncStreamControllerDispatch, _NoCallbacks) {
|
|
}
|
|
class _NoCallbackSyncStreamController extends dart.mixin(_SyncStreamControllerDispatch, _NoCallbacks) {
|
|
}
|
|
// Function _runGuarded: (() → dynamic) → Future<dynamic>
|
|
function _runGuarded(notificationHandler) {
|
|
if (notificationHandler === null)
|
|
return null;
|
|
try {
|
|
let result = notificationHandler();
|
|
if (dart.is(result, Future))
|
|
return dart.as(result, Future);
|
|
return null;
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
Zone.current.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
let _ControllerStream$ = dart.generic(function(T) {
|
|
class _ControllerStream extends _StreamImpl$(T) {
|
|
_ControllerStream(_controller) {
|
|
this._controller = _controller;
|
|
super._StreamImpl();
|
|
}
|
|
_createSubscription(onData, onError, onDone, cancelOnError) {
|
|
return this._controller._subscribe(onData, onError, onDone, cancelOnError);
|
|
}
|
|
get hashCode() {
|
|
return this._controller.hashCode ^ 892482866;
|
|
}
|
|
['=='](other) {
|
|
if (core.identical(this, other))
|
|
return true;
|
|
if (!dart.is(other, _ControllerStream))
|
|
return false;
|
|
let otherStream = dart.as(other, _ControllerStream);
|
|
return core.identical(otherStream._controller, this._controller);
|
|
}
|
|
}
|
|
return _ControllerStream;
|
|
});
|
|
let _ControllerStream = _ControllerStream$(dynamic);
|
|
let _ControllerSubscription$ = dart.generic(function(T) {
|
|
class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
|
|
_ControllerSubscription(_controller, onData, onError, onDone, cancelOnError) {
|
|
this._controller = _controller;
|
|
super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
|
|
}
|
|
_onCancel() {
|
|
return this._controller._recordCancel(this);
|
|
}
|
|
_onPause() {
|
|
this._controller._recordPause(this);
|
|
}
|
|
_onResume() {
|
|
this._controller._recordResume(this);
|
|
}
|
|
}
|
|
return _ControllerSubscription;
|
|
});
|
|
let _ControllerSubscription = _ControllerSubscription$(dynamic);
|
|
let _StreamSinkWrapper$ = dart.generic(function(T) {
|
|
class _StreamSinkWrapper extends dart.Object {
|
|
_StreamSinkWrapper(_target) {
|
|
this._target = _target;
|
|
}
|
|
add(data) {
|
|
this._target.add(data);
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
this._target.addError(error, stackTrace);
|
|
}
|
|
close() {
|
|
return this._target.close();
|
|
}
|
|
addStream(source, opt$) {
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? true : opt$.cancelOnError;
|
|
return this._target.addStream(source, {cancelOnError: cancelOnError});
|
|
}
|
|
get done() {
|
|
return this._target.done;
|
|
}
|
|
}
|
|
return _StreamSinkWrapper;
|
|
});
|
|
let _StreamSinkWrapper = _StreamSinkWrapper$(dynamic);
|
|
let _AddStreamState$ = dart.generic(function(T) {
|
|
class _AddStreamState extends dart.Object {
|
|
_AddStreamState(controller, source, cancelOnError) {
|
|
this.addStreamFuture = new _Future();
|
|
this.addSubscription = source.listen(dart.as(controller._add, dart.throw_("Unimplemented type (dynamic) → void")), {onError: dart.as(cancelOnError ? makeErrorHandler(controller) : controller._addError, core.Function), onDone: controller._close, cancelOnError: cancelOnError});
|
|
}
|
|
static makeErrorHandler(controller) {
|
|
return ((e, s) => {
|
|
controller._addError(e, s);
|
|
controller._close();
|
|
}).bind(this);
|
|
}
|
|
pause() {
|
|
this.addSubscription.pause();
|
|
}
|
|
resume() {
|
|
this.addSubscription.resume();
|
|
}
|
|
cancel() {
|
|
let cancel = this.addSubscription.cancel();
|
|
if (cancel === null) {
|
|
this.addStreamFuture._asyncComplete(null);
|
|
return null;
|
|
}
|
|
return cancel.whenComplete((() => {
|
|
this.addStreamFuture._asyncComplete(null);
|
|
}).bind(this));
|
|
}
|
|
complete() {
|
|
this.addStreamFuture._asyncComplete(null);
|
|
}
|
|
}
|
|
return _AddStreamState;
|
|
});
|
|
let _AddStreamState = _AddStreamState$(dynamic);
|
|
let _StreamControllerAddStreamState$ = dart.generic(function(T) {
|
|
class _StreamControllerAddStreamState extends _AddStreamState$(T) {
|
|
_StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
|
|
this.varData = varData;
|
|
super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
|
|
if (controller.isPaused) {
|
|
this.addSubscription.pause();
|
|
}
|
|
}
|
|
}
|
|
return _StreamControllerAddStreamState;
|
|
});
|
|
let _StreamControllerAddStreamState = _StreamControllerAddStreamState$(dynamic);
|
|
let _EventSink$ = dart.generic(function(T) {
|
|
class _EventSink extends dart.Object {
|
|
}
|
|
return _EventSink;
|
|
});
|
|
let _EventSink = _EventSink$(dynamic);
|
|
let _EventDispatch$ = dart.generic(function(T) {
|
|
class _EventDispatch extends dart.Object {
|
|
}
|
|
return _EventDispatch;
|
|
});
|
|
let _EventDispatch = _EventDispatch$(dynamic);
|
|
let _BufferingStreamSubscription$ = dart.generic(function(T) {
|
|
class _BufferingStreamSubscription extends dart.Object {
|
|
_BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
|
|
this._zone = Zone.current;
|
|
this._state = cancelOnError ? _STATE_CANCEL_ON_ERROR : 0;
|
|
this._onData = null;
|
|
this._onError = null;
|
|
this._onDone = null;
|
|
this._cancelFuture = null;
|
|
this._pending = null;
|
|
this.onData(onData);
|
|
this.onError(onError);
|
|
this.onDone(onDone);
|
|
}
|
|
_setPendingEvents(pendingEvents) {
|
|
dart.assert(this._pending === null);
|
|
if (pendingEvents === null)
|
|
return;
|
|
this._pending = pendingEvents;
|
|
if (!dart.notNull(pendingEvents.isEmpty)) {
|
|
this._state = _STATE_HAS_PENDING;
|
|
this._pending.schedule(this);
|
|
}
|
|
}
|
|
_extractPending() {
|
|
dart.assert(this._isCanceled);
|
|
let events = this._pending;
|
|
this._pending = null;
|
|
return events;
|
|
}
|
|
onData(handleData) {
|
|
if (handleData === null)
|
|
handleData = _nullDataHandler;
|
|
this._onData = this._zone.registerUnaryCallback(dart.as(handleData, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
}
|
|
onError(handleError) {
|
|
if (handleError === null)
|
|
handleError = _nullErrorHandler;
|
|
this._onError = _registerErrorHandler(handleError, this._zone);
|
|
}
|
|
onDone(handleDone) {
|
|
if (handleDone === null)
|
|
handleDone = _nullDoneHandler;
|
|
this._onDone = this._zone.registerCallback(handleDone);
|
|
}
|
|
pause(resumeSignal) {
|
|
if (resumeSignal === void 0)
|
|
resumeSignal = null;
|
|
if (this._isCanceled)
|
|
return;
|
|
let wasPaused = this._isPaused;
|
|
let wasInputPaused = this._isInputPaused;
|
|
this._state = this._state + _STATE_PAUSE_COUNT | _STATE_INPUT_PAUSED;
|
|
if (resumeSignal !== null)
|
|
resumeSignal.whenComplete(this.resume);
|
|
if (dart.notNull(!dart.notNull(wasPaused)) && dart.notNull(this._pending !== null))
|
|
this._pending.cancelSchedule();
|
|
if (dart.notNull(!dart.notNull(wasInputPaused)) && dart.notNull(!dart.notNull(this._inCallback)))
|
|
this._guardCallback(this._onPause);
|
|
}
|
|
resume() {
|
|
if (this._isCanceled)
|
|
return;
|
|
if (this._isPaused) {
|
|
this._decrementPauseCount();
|
|
if (!dart.notNull(this._isPaused)) {
|
|
if (dart.notNull(this._hasPending) && dart.notNull(!dart.notNull(this._pending.isEmpty))) {
|
|
this._pending.schedule(this);
|
|
} else {
|
|
dart.assert(this._mayResumeInput);
|
|
this._state = ~_STATE_INPUT_PAUSED;
|
|
if (!dart.notNull(this._inCallback))
|
|
this._guardCallback(this._onResume);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cancel() {
|
|
this._state = ~_STATE_WAIT_FOR_CANCEL;
|
|
if (this._isCanceled)
|
|
return this._cancelFuture;
|
|
this._cancel();
|
|
return this._cancelFuture;
|
|
}
|
|
asFuture(futureValue) {
|
|
if (futureValue === void 0)
|
|
futureValue = null;
|
|
let result = new _Future();
|
|
this._onDone = (() => {
|
|
result._complete(futureValue);
|
|
}).bind(this);
|
|
this._onError = ((error, stackTrace) => {
|
|
this.cancel();
|
|
result._completeError(error, dart.as(stackTrace, core.StackTrace));
|
|
}).bind(this);
|
|
return result;
|
|
}
|
|
get _isInputPaused() {
|
|
return (this._state & _STATE_INPUT_PAUSED) !== 0;
|
|
}
|
|
get _isClosed() {
|
|
return (this._state & _STATE_CLOSED) !== 0;
|
|
}
|
|
get _isCanceled() {
|
|
return (this._state & _STATE_CANCELED) !== 0;
|
|
}
|
|
get _waitsForCancel() {
|
|
return (this._state & _STATE_WAIT_FOR_CANCEL) !== 0;
|
|
}
|
|
get _inCallback() {
|
|
return (this._state & _STATE_IN_CALLBACK) !== 0;
|
|
}
|
|
get _hasPending() {
|
|
return (this._state & _STATE_HAS_PENDING) !== 0;
|
|
}
|
|
get _isPaused() {
|
|
return this._state >= _STATE_PAUSE_COUNT;
|
|
}
|
|
get _canFire() {
|
|
return this._state < _STATE_IN_CALLBACK;
|
|
}
|
|
get _mayResumeInput() {
|
|
return dart.notNull(!dart.notNull(this._isPaused)) && dart.notNull(dart.notNull(this._pending === null) || dart.notNull(this._pending.isEmpty));
|
|
}
|
|
get _cancelOnError() {
|
|
return (this._state & _STATE_CANCEL_ON_ERROR) !== 0;
|
|
}
|
|
get isPaused() {
|
|
return this._isPaused;
|
|
}
|
|
_cancel() {
|
|
this._state = _STATE_CANCELED;
|
|
if (this._hasPending) {
|
|
this._pending.cancelSchedule();
|
|
}
|
|
if (!dart.notNull(this._inCallback))
|
|
this._pending = null;
|
|
this._cancelFuture = this._onCancel();
|
|
}
|
|
_incrementPauseCount() {
|
|
this._state = this._state + _STATE_PAUSE_COUNT | _STATE_INPUT_PAUSED;
|
|
}
|
|
_decrementPauseCount() {
|
|
dart.assert(this._isPaused);
|
|
this._state = _STATE_PAUSE_COUNT;
|
|
}
|
|
_add(data) {
|
|
dart.assert(!dart.notNull(this._isClosed));
|
|
if (this._isCanceled)
|
|
return;
|
|
if (this._canFire) {
|
|
this._sendData(data);
|
|
} else {
|
|
this._addPending(new _DelayedData(data));
|
|
}
|
|
}
|
|
_addError(error, stackTrace) {
|
|
if (this._isCanceled)
|
|
return;
|
|
if (this._canFire) {
|
|
this._sendError(error, stackTrace);
|
|
} else {
|
|
this._addPending(new _DelayedError(error, stackTrace));
|
|
}
|
|
}
|
|
_close() {
|
|
dart.assert(!dart.notNull(this._isClosed));
|
|
if (this._isCanceled)
|
|
return;
|
|
this._state = _STATE_CLOSED;
|
|
if (this._canFire) {
|
|
this._sendDone();
|
|
} else {
|
|
this._addPending(new _DelayedDone());
|
|
}
|
|
}
|
|
_onPause() {
|
|
dart.assert(this._isInputPaused);
|
|
}
|
|
_onResume() {
|
|
dart.assert(!dart.notNull(this._isInputPaused));
|
|
}
|
|
_onCancel() {
|
|
dart.assert(this._isCanceled);
|
|
return null;
|
|
}
|
|
_addPending(event) {
|
|
let pending = dart.as(this._pending, _StreamImplEvents);
|
|
if (this._pending === null)
|
|
pending = this._pending = new _StreamImplEvents();
|
|
pending.add(event);
|
|
if (!dart.notNull(this._hasPending)) {
|
|
this._state = _STATE_HAS_PENDING;
|
|
if (!dart.notNull(this._isPaused)) {
|
|
this._pending.schedule(this);
|
|
}
|
|
}
|
|
}
|
|
_sendData(data) {
|
|
dart.assert(!dart.notNull(this._isCanceled));
|
|
dart.assert(!dart.notNull(this._isPaused));
|
|
dart.assert(!dart.notNull(this._inCallback));
|
|
let wasInputPaused = this._isInputPaused;
|
|
this._state = _STATE_IN_CALLBACK;
|
|
this._zone.runUnaryGuarded(dart.as(this._onData, dart.throw_("Unimplemented type (dynamic) → dynamic")), data);
|
|
this._state = ~_STATE_IN_CALLBACK;
|
|
this._checkState(wasInputPaused);
|
|
}
|
|
_sendError(error, stackTrace) {
|
|
dart.assert(!dart.notNull(this._isCanceled));
|
|
dart.assert(!dart.notNull(this._isPaused));
|
|
dart.assert(!dart.notNull(this._inCallback));
|
|
let wasInputPaused = this._isInputPaused;
|
|
// Function sendError: () → void
|
|
function sendError() {
|
|
if (dart.notNull(this._isCanceled) && dart.notNull(!dart.notNull(this._waitsForCancel)))
|
|
return;
|
|
this._state = _STATE_IN_CALLBACK;
|
|
if (dart.is(this._onError, ZoneBinaryCallback)) {
|
|
this._zone.runBinaryGuarded(dart.as(this._onError, dart.throw_("Unimplemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
|
|
} else {
|
|
this._zone.runUnaryGuarded(dart.as(this._onError, dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
|
|
}
|
|
this._state = ~_STATE_IN_CALLBACK;
|
|
}
|
|
if (this._cancelOnError) {
|
|
this._state = _STATE_WAIT_FOR_CANCEL;
|
|
this._cancel();
|
|
if (dart.is(this._cancelFuture, Future)) {
|
|
this._cancelFuture.whenComplete(sendError);
|
|
} else {
|
|
sendError();
|
|
}
|
|
} else {
|
|
sendError();
|
|
this._checkState(wasInputPaused);
|
|
}
|
|
}
|
|
_sendDone() {
|
|
dart.assert(!dart.notNull(this._isCanceled));
|
|
dart.assert(!dart.notNull(this._isPaused));
|
|
dart.assert(!dart.notNull(this._inCallback));
|
|
// Function sendDone: () → void
|
|
function sendDone() {
|
|
if (!dart.notNull(this._waitsForCancel))
|
|
return;
|
|
this._state = _STATE_CANCELED | _STATE_CLOSED | _STATE_IN_CALLBACK;
|
|
this._zone.runGuarded(this._onDone);
|
|
this._state = ~_STATE_IN_CALLBACK;
|
|
}
|
|
this._cancel();
|
|
this._state = _STATE_WAIT_FOR_CANCEL;
|
|
if (dart.is(this._cancelFuture, Future)) {
|
|
this._cancelFuture.whenComplete(sendDone);
|
|
} else {
|
|
sendDone();
|
|
}
|
|
}
|
|
_guardCallback(callback) {
|
|
dart.assert(!dart.notNull(this._inCallback));
|
|
let wasInputPaused = this._isInputPaused;
|
|
this._state = _STATE_IN_CALLBACK;
|
|
dart.dinvokef(callback);
|
|
this._state = ~_STATE_IN_CALLBACK;
|
|
this._checkState(wasInputPaused);
|
|
}
|
|
_checkState(wasInputPaused) {
|
|
dart.assert(!dart.notNull(this._inCallback));
|
|
if (dart.notNull(this._hasPending) && dart.notNull(this._pending.isEmpty)) {
|
|
this._state = ~_STATE_HAS_PENDING;
|
|
if (dart.notNull(this._isInputPaused) && dart.notNull(this._mayResumeInput)) {
|
|
this._state = ~_STATE_INPUT_PAUSED;
|
|
}
|
|
}
|
|
while (true) {
|
|
if (this._isCanceled) {
|
|
this._pending = null;
|
|
return;
|
|
}
|
|
let isInputPaused = this._isInputPaused;
|
|
if (wasInputPaused === isInputPaused)
|
|
break;
|
|
this._state = _STATE_IN_CALLBACK;
|
|
if (isInputPaused) {
|
|
this._onPause();
|
|
} else {
|
|
this._onResume();
|
|
}
|
|
this._state = ~_STATE_IN_CALLBACK;
|
|
wasInputPaused = isInputPaused;
|
|
}
|
|
if (dart.notNull(this._hasPending) && dart.notNull(!dart.notNull(this._isPaused))) {
|
|
this._pending.schedule(this);
|
|
}
|
|
}
|
|
}
|
|
_BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
|
|
_BufferingStreamSubscription._STATE_CLOSED = 2;
|
|
_BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
|
|
_BufferingStreamSubscription._STATE_CANCELED = 8;
|
|
_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
|
|
_BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
|
|
_BufferingStreamSubscription._STATE_HAS_PENDING = 64;
|
|
_BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
|
|
_BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
|
|
return _BufferingStreamSubscription;
|
|
});
|
|
let _BufferingStreamSubscription = _BufferingStreamSubscription$(dynamic);
|
|
let _StreamImpl$ = dart.generic(function(T) {
|
|
class _StreamImpl extends Stream$(T) {
|
|
listen(onData, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
|
|
cancelOnError = core.identical(true, cancelOnError);
|
|
let subscription = this._createSubscription(onData, onError, onDone, cancelOnError);
|
|
this._onListen(subscription);
|
|
return dart.as(subscription, StreamSubscription$(T));
|
|
}
|
|
_createSubscription(onData, onError, onDone, cancelOnError) {
|
|
return new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
|
|
}
|
|
_onListen(subscription) {}
|
|
}
|
|
return _StreamImpl;
|
|
});
|
|
let _StreamImpl = _StreamImpl$(dynamic);
|
|
let _GeneratedStreamImpl$ = dart.generic(function(T) {
|
|
class _GeneratedStreamImpl extends _StreamImpl$(T) {
|
|
_GeneratedStreamImpl(_pending) {
|
|
this._pending = _pending;
|
|
this._isUsed = false;
|
|
super._StreamImpl();
|
|
}
|
|
_createSubscription(onData, onError, onDone, cancelOnError) {
|
|
if (this._isUsed)
|
|
throw new core.StateError("Stream has already been listened to.");
|
|
this._isUsed = true;
|
|
return ((_) => {
|
|
_._setPendingEvents(this._pending());
|
|
return _;
|
|
}).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
|
|
}
|
|
}
|
|
return _GeneratedStreamImpl;
|
|
});
|
|
let _GeneratedStreamImpl = _GeneratedStreamImpl$(dynamic);
|
|
let _IterablePendingEvents$ = dart.generic(function(T) {
|
|
class _IterablePendingEvents extends _PendingEvents {
|
|
_IterablePendingEvents(data) {
|
|
this._iterator = data.iterator;
|
|
super._PendingEvents();
|
|
}
|
|
get isEmpty() {
|
|
return this._iterator === null;
|
|
}
|
|
handleNext(dispatch) {
|
|
if (this._iterator === null) {
|
|
throw new core.StateError("No events pending.");
|
|
}
|
|
let isDone = null;
|
|
try {
|
|
isDone = !dart.notNull(this._iterator.moveNext());
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
this._iterator = null;
|
|
dispatch._sendError(e, s);
|
|
return;
|
|
}
|
|
|
|
if (!dart.notNull(isDone)) {
|
|
dispatch._sendData(this._iterator.current);
|
|
} else {
|
|
this._iterator = null;
|
|
dispatch._sendDone();
|
|
}
|
|
}
|
|
clear() {
|
|
if (this.isScheduled)
|
|
this.cancelSchedule();
|
|
this._iterator = null;
|
|
}
|
|
}
|
|
return _IterablePendingEvents;
|
|
});
|
|
let _IterablePendingEvents = _IterablePendingEvents$(dynamic);
|
|
// Function _nullDataHandler: (dynamic) → void
|
|
function _nullDataHandler(value) {
|
|
}
|
|
// Function _nullErrorHandler: (dynamic, [StackTrace]) → void
|
|
function _nullErrorHandler(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
Zone.current.handleUncaughtError(error, stackTrace);
|
|
}
|
|
// Function _nullDoneHandler: () → void
|
|
function _nullDoneHandler() {
|
|
}
|
|
class _DelayedEvent extends dart.Object {
|
|
_DelayedEvent() {
|
|
this.next = null;
|
|
}
|
|
}
|
|
let _DelayedData$ = dart.generic(function(T) {
|
|
class _DelayedData extends _DelayedEvent {
|
|
_DelayedData(value) {
|
|
this.value = value;
|
|
super._DelayedEvent();
|
|
}
|
|
perform(dispatch) {
|
|
dispatch._sendData(this.value);
|
|
}
|
|
}
|
|
return _DelayedData;
|
|
});
|
|
let _DelayedData = _DelayedData$(dynamic);
|
|
class _DelayedError extends _DelayedEvent {
|
|
_DelayedError(error, stackTrace) {
|
|
this.error = error;
|
|
this.stackTrace = stackTrace;
|
|
super._DelayedEvent();
|
|
}
|
|
perform(dispatch) {
|
|
dispatch._sendError(this.error, this.stackTrace);
|
|
}
|
|
}
|
|
class _DelayedDone extends dart.Object {
|
|
_DelayedDone() {
|
|
}
|
|
perform(dispatch) {
|
|
dispatch._sendDone();
|
|
}
|
|
get next() {
|
|
return null;
|
|
}
|
|
set next(_) {
|
|
throw new core.StateError("No events after a done.");
|
|
}
|
|
}
|
|
class _PendingEvents extends dart.Object {
|
|
_PendingEvents() {
|
|
this._state = _STATE_UNSCHEDULED;
|
|
}
|
|
get isScheduled() {
|
|
return this._state === _STATE_SCHEDULED;
|
|
}
|
|
get _eventScheduled() {
|
|
return this._state >= _STATE_SCHEDULED;
|
|
}
|
|
schedule(dispatch) {
|
|
if (this.isScheduled)
|
|
return;
|
|
dart.assert(!dart.notNull(this.isEmpty));
|
|
if (this._eventScheduled) {
|
|
dart.assert(this._state === _STATE_CANCELED);
|
|
this._state = _STATE_SCHEDULED;
|
|
return;
|
|
}
|
|
scheduleMicrotask((() => {
|
|
let oldState = this._state;
|
|
this._state = _STATE_UNSCHEDULED;
|
|
if (oldState === _STATE_CANCELED)
|
|
return;
|
|
this.handleNext(dispatch);
|
|
}).bind(this));
|
|
this._state = _STATE_SCHEDULED;
|
|
}
|
|
cancelSchedule() {
|
|
if (this.isScheduled)
|
|
this._state = _STATE_CANCELED;
|
|
}
|
|
}
|
|
_PendingEvents._STATE_UNSCHEDULED = 0;
|
|
_PendingEvents._STATE_SCHEDULED = 1;
|
|
_PendingEvents._STATE_CANCELED = 3;
|
|
class _StreamImplEvents extends _PendingEvents {
|
|
_StreamImplEvents() {
|
|
this.firstPendingEvent = null;
|
|
this.lastPendingEvent = null;
|
|
super._PendingEvents();
|
|
}
|
|
get isEmpty() {
|
|
return this.lastPendingEvent === null;
|
|
}
|
|
add(event) {
|
|
if (this.lastPendingEvent === null) {
|
|
this.firstPendingEvent = this.lastPendingEvent = event;
|
|
} else {
|
|
this.lastPendingEvent = this.lastPendingEvent.next = event;
|
|
}
|
|
}
|
|
handleNext(dispatch) {
|
|
dart.assert(!dart.notNull(this.isScheduled));
|
|
let event = this.firstPendingEvent;
|
|
this.firstPendingEvent = event.next;
|
|
if (this.firstPendingEvent === null) {
|
|
this.lastPendingEvent = null;
|
|
}
|
|
event.perform(dispatch);
|
|
}
|
|
clear() {
|
|
if (this.isScheduled)
|
|
this.cancelSchedule();
|
|
this.firstPendingEvent = this.lastPendingEvent = null;
|
|
}
|
|
}
|
|
class _BroadcastLinkedList extends dart.Object {
|
|
_BroadcastLinkedList() {
|
|
this._next = null;
|
|
this._previous = null;
|
|
}
|
|
_unlink() {
|
|
this._previous._next = this._next;
|
|
this._next._previous = this._previous;
|
|
this._next = this._previous = this;
|
|
}
|
|
_insertBefore(newNext) {
|
|
let newPrevious = newNext._previous;
|
|
newPrevious._next = this;
|
|
newNext._previous = this._previous;
|
|
this._previous._next = newNext;
|
|
this._previous = newPrevious;
|
|
}
|
|
}
|
|
let _DoneStreamSubscription$ = dart.generic(function(T) {
|
|
class _DoneStreamSubscription extends dart.Object {
|
|
_DoneStreamSubscription(_onDone) {
|
|
this._onDone = _onDone;
|
|
this._zone = Zone.current;
|
|
this._state = 0;
|
|
this._schedule();
|
|
}
|
|
get _isSent() {
|
|
return (this._state & _DONE_SENT) !== 0;
|
|
}
|
|
get _isScheduled() {
|
|
return (this._state & _SCHEDULED) !== 0;
|
|
}
|
|
get isPaused() {
|
|
return this._state >= _PAUSED;
|
|
}
|
|
_schedule() {
|
|
if (this._isScheduled)
|
|
return;
|
|
this._zone.scheduleMicrotask(this._sendDone);
|
|
this._state = _SCHEDULED;
|
|
}
|
|
onData(handleData) {}
|
|
onError(handleError) {}
|
|
onDone(handleDone) {
|
|
this._onDone = handleDone;
|
|
}
|
|
pause(resumeSignal) {
|
|
if (resumeSignal === void 0)
|
|
resumeSignal = null;
|
|
this._state = _PAUSED;
|
|
if (resumeSignal !== null)
|
|
resumeSignal.whenComplete(this.resume);
|
|
}
|
|
resume() {
|
|
if (this.isPaused) {
|
|
this._state = _PAUSED;
|
|
if (dart.notNull(!dart.notNull(this.isPaused)) && dart.notNull(!dart.notNull(this._isSent))) {
|
|
this._schedule();
|
|
}
|
|
}
|
|
}
|
|
cancel() {
|
|
return null;
|
|
}
|
|
asFuture(futureValue) {
|
|
if (futureValue === void 0)
|
|
futureValue = null;
|
|
let result = new _Future();
|
|
this._onDone = (() => {
|
|
result._completeWithValue(null);
|
|
}).bind(this);
|
|
return result;
|
|
}
|
|
_sendDone() {
|
|
this._state = ~_SCHEDULED;
|
|
if (this.isPaused)
|
|
return;
|
|
this._state = _DONE_SENT;
|
|
if (this._onDone !== null)
|
|
this._zone.runGuarded(this._onDone);
|
|
}
|
|
}
|
|
_DoneStreamSubscription._DONE_SENT = 1;
|
|
_DoneStreamSubscription._SCHEDULED = 2;
|
|
_DoneStreamSubscription._PAUSED = 4;
|
|
return _DoneStreamSubscription;
|
|
});
|
|
let _DoneStreamSubscription = _DoneStreamSubscription$(dynamic);
|
|
let _AsBroadcastStream$ = dart.generic(function(T) {
|
|
class _AsBroadcastStream extends Stream$(T) {
|
|
_AsBroadcastStream(_source, onListenHandler, onCancelHandler) {
|
|
this._source = _source;
|
|
this._onListenHandler = Zone.current.registerUnaryCallback(dart.as(onListenHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
this._onCancelHandler = Zone.current.registerUnaryCallback(dart.as(onCancelHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
this._zone = Zone.current;
|
|
this._controller = null;
|
|
this._subscription = null;
|
|
super.Stream();
|
|
this._controller = new _AsBroadcastStreamController(this._onListen, this._onCancel);
|
|
}
|
|
get isBroadcast() {
|
|
return true;
|
|
}
|
|
listen(onData, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
|
|
if (dart.notNull(this._controller === null) || dart.notNull(this._controller.isClosed)) {
|
|
return new _DoneStreamSubscription(onDone);
|
|
}
|
|
if (this._subscription === null) {
|
|
this._subscription = this._source.listen(this._controller.add, {onError: this._controller.addError, onDone: this._controller.close});
|
|
}
|
|
cancelOnError = core.identical(true, cancelOnError);
|
|
return this._controller._subscribe(onData, onError, onDone, cancelOnError);
|
|
}
|
|
_onCancel() {
|
|
let shutdown = dart.notNull(this._controller === null) || dart.notNull(this._controller.isClosed);
|
|
if (this._onCancelHandler !== null) {
|
|
this._zone.runUnary(dart.as(this._onCancelHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")), new _BroadcastSubscriptionWrapper(this));
|
|
}
|
|
if (shutdown) {
|
|
if (this._subscription !== null) {
|
|
this._subscription.cancel();
|
|
this._subscription = null;
|
|
}
|
|
}
|
|
}
|
|
_onListen() {
|
|
if (this._onListenHandler !== null) {
|
|
this._zone.runUnary(dart.as(this._onListenHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")), new _BroadcastSubscriptionWrapper(this));
|
|
}
|
|
}
|
|
_cancelSubscription() {
|
|
if (this._subscription === null)
|
|
return;
|
|
let subscription = this._subscription;
|
|
this._subscription = null;
|
|
this._controller = null;
|
|
subscription.cancel();
|
|
}
|
|
_pauseSubscription(resumeSignal) {
|
|
if (this._subscription === null)
|
|
return;
|
|
this._subscription.pause(resumeSignal);
|
|
}
|
|
_resumeSubscription() {
|
|
if (this._subscription === null)
|
|
return;
|
|
this._subscription.resume();
|
|
}
|
|
get _isSubscriptionPaused() {
|
|
if (this._subscription === null)
|
|
return false;
|
|
return this._subscription.isPaused;
|
|
}
|
|
}
|
|
return _AsBroadcastStream;
|
|
});
|
|
let _AsBroadcastStream = _AsBroadcastStream$(dynamic);
|
|
let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
|
|
class _BroadcastSubscriptionWrapper extends dart.Object {
|
|
_BroadcastSubscriptionWrapper(_stream) {
|
|
this._stream = _stream;
|
|
}
|
|
onData(handleData) {
|
|
throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
|
|
}
|
|
onError(handleError) {
|
|
throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
|
|
}
|
|
onDone(handleDone) {
|
|
throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
|
|
}
|
|
pause(resumeSignal) {
|
|
if (resumeSignal === void 0)
|
|
resumeSignal = null;
|
|
this._stream._pauseSubscription(resumeSignal);
|
|
}
|
|
resume() {
|
|
this._stream._resumeSubscription();
|
|
}
|
|
cancel() {
|
|
this._stream._cancelSubscription();
|
|
return null;
|
|
}
|
|
get isPaused() {
|
|
return this._stream._isSubscriptionPaused;
|
|
}
|
|
asFuture(futureValue) {
|
|
if (futureValue === void 0)
|
|
futureValue = null;
|
|
throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
|
|
}
|
|
}
|
|
return _BroadcastSubscriptionWrapper;
|
|
});
|
|
let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dynamic);
|
|
let _StreamIteratorImpl$ = dart.generic(function(T) {
|
|
class _StreamIteratorImpl extends dart.Object {
|
|
_StreamIteratorImpl(stream) {
|
|
this._subscription = null;
|
|
this._current = dart.as(null, T);
|
|
this._futureOrPrefetch = null;
|
|
this._state = _STATE_FOUND;
|
|
this._subscription = stream.listen(this._onData, {onError: this._onError, onDone: this._onDone, cancelOnError: true});
|
|
}
|
|
get current() {
|
|
return this._current;
|
|
}
|
|
moveNext() {
|
|
if (this._state === _STATE_DONE) {
|
|
return new _Future.immediate(false);
|
|
}
|
|
if (this._state === _STATE_MOVING) {
|
|
throw new core.StateError("Already waiting for next.");
|
|
}
|
|
if (this._state === _STATE_FOUND) {
|
|
this._state = _STATE_MOVING;
|
|
this._current = dart.as(null, T);
|
|
this._futureOrPrefetch = new _Future();
|
|
return dart.as(this._futureOrPrefetch, Future$(core.bool));
|
|
} else {
|
|
dart.assert(this._state >= _STATE_EXTRA_DATA);
|
|
switch (this._state) {
|
|
case _STATE_EXTRA_DATA:
|
|
this._state = _STATE_FOUND;
|
|
this._current = dart.as(this._futureOrPrefetch, T);
|
|
this._futureOrPrefetch = null;
|
|
this._subscription.resume();
|
|
return new _Future.immediate(true);
|
|
case _STATE_EXTRA_ERROR:
|
|
let prefetch = dart.as(this._futureOrPrefetch, AsyncError);
|
|
this._clear();
|
|
return new _Future.immediateError(prefetch.error, prefetch.stackTrace);
|
|
case _STATE_EXTRA_DONE:
|
|
this._clear();
|
|
return new _Future.immediate(false);
|
|
}
|
|
}
|
|
}
|
|
_clear() {
|
|
this._subscription = null;
|
|
this._futureOrPrefetch = null;
|
|
this._current = dart.as(null, T);
|
|
this._state = _STATE_DONE;
|
|
}
|
|
cancel() {
|
|
let subscription = this._subscription;
|
|
if (this._state === _STATE_MOVING) {
|
|
let hasNext = dart.as(this._futureOrPrefetch, _Future$(core.bool));
|
|
this._clear();
|
|
hasNext._complete(false);
|
|
} else {
|
|
this._clear();
|
|
}
|
|
return subscription.cancel();
|
|
}
|
|
_onData(data) {
|
|
if (this._state === _STATE_MOVING) {
|
|
this._current = data;
|
|
let hasNext = dart.as(this._futureOrPrefetch, _Future$(core.bool));
|
|
this._futureOrPrefetch = null;
|
|
this._state = _STATE_FOUND;
|
|
hasNext._complete(true);
|
|
return;
|
|
}
|
|
this._subscription.pause();
|
|
dart.assert(this._futureOrPrefetch === null);
|
|
this._futureOrPrefetch = data;
|
|
this._state = _STATE_EXTRA_DATA;
|
|
}
|
|
_onError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
if (this._state === _STATE_MOVING) {
|
|
let hasNext = dart.as(this._futureOrPrefetch, _Future$(core.bool));
|
|
this._clear();
|
|
hasNext._completeError(error, stackTrace);
|
|
return;
|
|
}
|
|
this._subscription.pause();
|
|
dart.assert(this._futureOrPrefetch === null);
|
|
this._futureOrPrefetch = new AsyncError(error, stackTrace);
|
|
this._state = _STATE_EXTRA_ERROR;
|
|
}
|
|
_onDone() {
|
|
if (this._state === _STATE_MOVING) {
|
|
let hasNext = dart.as(this._futureOrPrefetch, _Future$(core.bool));
|
|
this._clear();
|
|
hasNext._complete(false);
|
|
return;
|
|
}
|
|
this._subscription.pause();
|
|
this._futureOrPrefetch = null;
|
|
this._state = _STATE_EXTRA_DONE;
|
|
}
|
|
}
|
|
_StreamIteratorImpl._STATE_FOUND = 0;
|
|
_StreamIteratorImpl._STATE_DONE = 1;
|
|
_StreamIteratorImpl._STATE_MOVING = 2;
|
|
_StreamIteratorImpl._STATE_EXTRA_DATA = 3;
|
|
_StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
|
|
_StreamIteratorImpl._STATE_EXTRA_DONE = 5;
|
|
return _StreamIteratorImpl;
|
|
});
|
|
let _StreamIteratorImpl = _StreamIteratorImpl$(dynamic);
|
|
// Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → dynamic
|
|
function _runUserCode(userCode, onSuccess, onError) {
|
|
try {
|
|
onSuccess(userCode());
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
let replacement = Zone.current.errorCallback(e, s);
|
|
if (replacement === null) {
|
|
onError(e, s);
|
|
} else {
|
|
let error = _nonNullError(replacement.error);
|
|
let stackTrace = replacement.stackTrace;
|
|
onError(error, stackTrace);
|
|
}
|
|
}
|
|
|
|
}
|
|
// Function _cancelAndError: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
|
|
function _cancelAndError(subscription, future, error, stackTrace) {
|
|
let cancelFuture = subscription.cancel();
|
|
if (dart.is(cancelFuture, Future)) {
|
|
cancelFuture.whenComplete(() => future._completeError(error, stackTrace));
|
|
} else {
|
|
future._completeError(error, stackTrace);
|
|
}
|
|
}
|
|
// Function _cancelAndErrorWithReplacement: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic, StackTrace) → void
|
|
function _cancelAndErrorWithReplacement(subscription, future, error, stackTrace) {
|
|
let replacement = Zone.current.errorCallback(error, stackTrace);
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
_cancelAndError(subscription, future, error, stackTrace);
|
|
}
|
|
// Function _cancelAndErrorClosure: (StreamSubscription<dynamic>, _Future<dynamic>) → dynamic
|
|
function _cancelAndErrorClosure(subscription, future) {
|
|
return (error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace);
|
|
}
|
|
// Function _cancelAndValue: (StreamSubscription<dynamic>, _Future<dynamic>, dynamic) → void
|
|
function _cancelAndValue(subscription, future, value) {
|
|
let cancelFuture = subscription.cancel();
|
|
if (dart.is(cancelFuture, Future)) {
|
|
cancelFuture.whenComplete(() => future._complete(value));
|
|
} else {
|
|
future._complete(value);
|
|
}
|
|
}
|
|
let _ForwardingStream$ = dart.generic(function(S, T) {
|
|
class _ForwardingStream extends Stream$(T) {
|
|
_ForwardingStream(_source) {
|
|
this._source = _source;
|
|
super.Stream();
|
|
}
|
|
get isBroadcast() {
|
|
return this._source.isBroadcast;
|
|
}
|
|
listen(onData, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
|
|
cancelOnError = core.identical(true, cancelOnError);
|
|
return this._createSubscription(onData, onError, onDone, cancelOnError);
|
|
}
|
|
_createSubscription(onData, onError, onDone, cancelOnError) {
|
|
return new _ForwardingStreamSubscription(this, onData, onError, onDone, cancelOnError);
|
|
}
|
|
_handleData(data, sink) {
|
|
let outputData = data;
|
|
sink._add(outputData);
|
|
}
|
|
_handleError(error, stackTrace, sink) {
|
|
sink._addError(error, stackTrace);
|
|
}
|
|
_handleDone(sink) {
|
|
sink._close();
|
|
}
|
|
}
|
|
return _ForwardingStream;
|
|
});
|
|
let _ForwardingStream = _ForwardingStream$(dynamic, dynamic);
|
|
let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
|
|
class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
|
|
_ForwardingStreamSubscription(_stream, onData, onError, onDone, cancelOnError) {
|
|
this._stream = _stream;
|
|
this._subscription = null;
|
|
super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
|
|
this._subscription = this._stream._source.listen(this._handleData, {onError: this._handleError, onDone: this._handleDone});
|
|
}
|
|
_add(data) {
|
|
if (this._isClosed)
|
|
return;
|
|
super._add(data);
|
|
}
|
|
_addError(error, stackTrace) {
|
|
if (this._isClosed)
|
|
return;
|
|
super._addError(error, stackTrace);
|
|
}
|
|
_onPause() {
|
|
if (this._subscription === null)
|
|
return;
|
|
this._subscription.pause();
|
|
}
|
|
_onResume() {
|
|
if (this._subscription === null)
|
|
return;
|
|
this._subscription.resume();
|
|
}
|
|
_onCancel() {
|
|
if (this._subscription !== null) {
|
|
let subscription = this._subscription;
|
|
this._subscription = null;
|
|
subscription.cancel();
|
|
}
|
|
return null;
|
|
}
|
|
_handleData(data) {
|
|
this._stream._handleData(data, this);
|
|
}
|
|
_handleError(error, stackTrace) {
|
|
this._stream._handleError(error, stackTrace, this);
|
|
}
|
|
_handleDone() {
|
|
this._stream._handleDone(this);
|
|
}
|
|
}
|
|
return _ForwardingStreamSubscription;
|
|
});
|
|
let _ForwardingStreamSubscription = _ForwardingStreamSubscription$(dynamic, dynamic);
|
|
// Function _addErrorWithReplacement: (_EventSink<dynamic>, dynamic, dynamic) → void
|
|
function _addErrorWithReplacement(sink, error, stackTrace) {
|
|
let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
|
|
if (replacement !== null) {
|
|
error = _nonNullError(replacement.error);
|
|
stackTrace = replacement.stackTrace;
|
|
}
|
|
sink._addError(error, dart.as(stackTrace, core.StackTrace));
|
|
}
|
|
let _WhereStream$ = dart.generic(function(T) {
|
|
class _WhereStream extends _ForwardingStream$(T, T) {
|
|
_WhereStream(source, test) {
|
|
this._test = test;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
let satisfies = null;
|
|
try {
|
|
satisfies = this._test(inputEvent);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
return;
|
|
}
|
|
|
|
if (satisfies) {
|
|
sink._add(inputEvent);
|
|
}
|
|
}
|
|
}
|
|
return _WhereStream;
|
|
});
|
|
let _WhereStream = _WhereStream$(dynamic);
|
|
let _MapStream$ = dart.generic(function(S, T) {
|
|
class _MapStream extends _ForwardingStream$(S, T) {
|
|
_MapStream(source, transform) {
|
|
this._transform = transform;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
let outputEvent = null;
|
|
try {
|
|
outputEvent = dart.as(this._transform(inputEvent), T);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
return;
|
|
}
|
|
|
|
sink._add(outputEvent);
|
|
}
|
|
}
|
|
return _MapStream;
|
|
});
|
|
let _MapStream = _MapStream$(dynamic, dynamic);
|
|
let _ExpandStream$ = dart.generic(function(S, T) {
|
|
class _ExpandStream extends _ForwardingStream$(S, T) {
|
|
_ExpandStream(source, expand) {
|
|
this._expand = expand;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
try {
|
|
for (let value of this._expand(inputEvent)) {
|
|
sink._add(value);
|
|
}
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
}
|
|
|
|
}
|
|
}
|
|
return _ExpandStream;
|
|
});
|
|
let _ExpandStream = _ExpandStream$(dynamic, dynamic);
|
|
let _HandleErrorStream$ = dart.generic(function(T) {
|
|
class _HandleErrorStream extends _ForwardingStream$(T, T) {
|
|
_HandleErrorStream(source, onError, test) {
|
|
this._transform = onError;
|
|
this._test = test;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleError(error, stackTrace, sink) {
|
|
let matches = true;
|
|
if (this._test !== null) {
|
|
try {
|
|
matches = this._test(error);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
return;
|
|
}
|
|
|
|
}
|
|
if (matches) {
|
|
try {
|
|
_invokeErrorHandler(this._transform, error, stackTrace);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
if (core.identical(e, error)) {
|
|
sink._addError(error, stackTrace);
|
|
} else {
|
|
_addErrorWithReplacement(sink, e, s);
|
|
}
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
sink._addError(error, stackTrace);
|
|
}
|
|
}
|
|
}
|
|
return _HandleErrorStream;
|
|
});
|
|
let _HandleErrorStream = _HandleErrorStream$(dynamic);
|
|
let _TakeStream$ = dart.generic(function(T) {
|
|
class _TakeStream extends _ForwardingStream$(T, T) {
|
|
_TakeStream(source, count) {
|
|
this._remaining = count;
|
|
super._ForwardingStream(source);
|
|
if (!(typeof count == number))
|
|
throw new core.ArgumentError(count);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
if (this._remaining > 0) {
|
|
sink._add(inputEvent);
|
|
this._remaining = 1;
|
|
if (this._remaining === 0) {
|
|
sink._close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return _TakeStream;
|
|
});
|
|
let _TakeStream = _TakeStream$(dynamic);
|
|
let _TakeWhileStream$ = dart.generic(function(T) {
|
|
class _TakeWhileStream extends _ForwardingStream$(T, T) {
|
|
_TakeWhileStream(source, test) {
|
|
this._test = test;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
let satisfies = null;
|
|
try {
|
|
satisfies = this._test(inputEvent);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
sink._close();
|
|
return;
|
|
}
|
|
|
|
if (satisfies) {
|
|
sink._add(inputEvent);
|
|
} else {
|
|
sink._close();
|
|
}
|
|
}
|
|
}
|
|
return _TakeWhileStream;
|
|
});
|
|
let _TakeWhileStream = _TakeWhileStream$(dynamic);
|
|
let _SkipStream$ = dart.generic(function(T) {
|
|
class _SkipStream extends _ForwardingStream$(T, T) {
|
|
_SkipStream(source, count) {
|
|
this._remaining = count;
|
|
super._ForwardingStream(source);
|
|
if (dart.notNull(!(typeof count == number)) || dart.notNull(count < 0))
|
|
throw new core.ArgumentError(count);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
if (this._remaining > 0) {
|
|
this._remaining--;
|
|
return;
|
|
}
|
|
sink._add(inputEvent);
|
|
}
|
|
}
|
|
return _SkipStream;
|
|
});
|
|
let _SkipStream = _SkipStream$(dynamic);
|
|
let _SkipWhileStream$ = dart.generic(function(T) {
|
|
class _SkipWhileStream extends _ForwardingStream$(T, T) {
|
|
_SkipWhileStream(source, test) {
|
|
this._test = test;
|
|
this._hasFailed = false;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
if (this._hasFailed) {
|
|
sink._add(inputEvent);
|
|
return;
|
|
}
|
|
let satisfies = null;
|
|
try {
|
|
satisfies = this._test(inputEvent);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
this._hasFailed = true;
|
|
return;
|
|
}
|
|
|
|
if (!dart.notNull(satisfies)) {
|
|
this._hasFailed = true;
|
|
sink._add(inputEvent);
|
|
}
|
|
}
|
|
}
|
|
return _SkipWhileStream;
|
|
});
|
|
let _SkipWhileStream = _SkipWhileStream$(dynamic);
|
|
let _DistinctStream$ = dart.generic(function(T) {
|
|
class _DistinctStream extends _ForwardingStream$(T, T) {
|
|
_DistinctStream(source, equals) {
|
|
this._previous = _SENTINEL;
|
|
this._equals = equals;
|
|
super._ForwardingStream(source);
|
|
}
|
|
_handleData(inputEvent, sink) {
|
|
if (core.identical(this._previous, _SENTINEL)) {
|
|
this._previous = inputEvent;
|
|
return sink._add(inputEvent);
|
|
} else {
|
|
let isEqual = null;
|
|
try {
|
|
if (this._equals === null) {
|
|
isEqual = dart.equals(this._previous, inputEvent);
|
|
} else {
|
|
isEqual = this._equals(dart.as(this._previous, T), inputEvent);
|
|
}
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
_addErrorWithReplacement(sink, e, s);
|
|
return null;
|
|
}
|
|
|
|
if (!dart.notNull(isEqual)) {
|
|
sink._add(inputEvent);
|
|
this._previous = inputEvent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
dart.defineLazyProperties(_DistinctStream, {
|
|
get _SENTINEL() {
|
|
return new core.Object();
|
|
},
|
|
set _SENTINEL() {}
|
|
});
|
|
return _DistinctStream;
|
|
});
|
|
let _DistinctStream = _DistinctStream$(dynamic);
|
|
let _EventSinkWrapper$ = dart.generic(function(T) {
|
|
class _EventSinkWrapper extends dart.Object {
|
|
_EventSinkWrapper(_sink) {
|
|
this._sink = _sink;
|
|
}
|
|
add(data) {
|
|
this._sink._add(data);
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
this._sink._addError(error, stackTrace);
|
|
}
|
|
close() {
|
|
this._sink._close();
|
|
}
|
|
}
|
|
return _EventSinkWrapper;
|
|
});
|
|
let _EventSinkWrapper = _EventSinkWrapper$(dynamic);
|
|
let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
|
|
class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
|
|
_SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
|
|
this._transformerSink = null;
|
|
this._subscription = null;
|
|
super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
|
|
let eventSink = new _EventSinkWrapper(this);
|
|
this._transformerSink = mapper(eventSink);
|
|
this._subscription = source.listen(this._handleData, {onError: this._handleError, onDone: this._handleDone});
|
|
}
|
|
get _isSubscribed() {
|
|
return this._subscription !== null;
|
|
}
|
|
_add(data) {
|
|
if (this._isClosed) {
|
|
throw new core.StateError("Stream is already closed");
|
|
}
|
|
super._add(data);
|
|
}
|
|
_addError(error, stackTrace) {
|
|
if (this._isClosed) {
|
|
throw new core.StateError("Stream is already closed");
|
|
}
|
|
super._addError(error, stackTrace);
|
|
}
|
|
_close() {
|
|
if (this._isClosed) {
|
|
throw new core.StateError("Stream is already closed");
|
|
}
|
|
super._close();
|
|
}
|
|
_onPause() {
|
|
if (this._isSubscribed)
|
|
this._subscription.pause();
|
|
}
|
|
_onResume() {
|
|
if (this._isSubscribed)
|
|
this._subscription.resume();
|
|
}
|
|
_onCancel() {
|
|
if (this._isSubscribed) {
|
|
let subscription = this._subscription;
|
|
this._subscription = null;
|
|
subscription.cancel();
|
|
}
|
|
return null;
|
|
}
|
|
_handleData(data) {
|
|
try {
|
|
this._transformerSink.add(data);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
this._addError(e, s);
|
|
}
|
|
|
|
}
|
|
_handleError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
try {
|
|
this._transformerSink.addError(error, dart.as(stackTrace, core.StackTrace));
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
if (core.identical(e, error)) {
|
|
this._addError(error, dart.as(stackTrace, core.StackTrace));
|
|
} else {
|
|
this._addError(e, s);
|
|
}
|
|
}
|
|
|
|
}
|
|
_handleDone() {
|
|
try {
|
|
this._subscription = null;
|
|
this._transformerSink.close();
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
this._addError(e, s);
|
|
}
|
|
|
|
}
|
|
}
|
|
return _SinkTransformerStreamSubscription;
|
|
});
|
|
let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$(dynamic, dynamic);
|
|
let _StreamSinkTransformer$ = dart.generic(function(S, T) {
|
|
class _StreamSinkTransformer extends dart.Object {
|
|
_StreamSinkTransformer(_sinkMapper) {
|
|
this._sinkMapper = _sinkMapper;
|
|
}
|
|
bind(stream) {
|
|
return new _BoundSinkStream(stream, this._sinkMapper);
|
|
}
|
|
}
|
|
return _StreamSinkTransformer;
|
|
});
|
|
let _StreamSinkTransformer = _StreamSinkTransformer$(dynamic, dynamic);
|
|
let _BoundSinkStream$ = dart.generic(function(S, T) {
|
|
class _BoundSinkStream extends Stream$(T) {
|
|
get isBroadcast() {
|
|
return this._stream.isBroadcast;
|
|
}
|
|
_BoundSinkStream(_stream, _sinkMapper) {
|
|
this._stream = _stream;
|
|
this._sinkMapper = _sinkMapper;
|
|
super.Stream();
|
|
}
|
|
listen(onData, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
|
|
cancelOnError = core.identical(true, cancelOnError);
|
|
let subscription = dart.as(new _SinkTransformerStreamSubscription(this._stream, this._sinkMapper, onData, onError, onDone, cancelOnError), StreamSubscription$(T));
|
|
return subscription;
|
|
}
|
|
}
|
|
return _BoundSinkStream;
|
|
});
|
|
let _BoundSinkStream = _BoundSinkStream$(dynamic, dynamic);
|
|
let _HandlerEventSink$ = dart.generic(function(S, T) {
|
|
class _HandlerEventSink extends dart.Object {
|
|
_HandlerEventSink(_handleData, _handleError, _handleDone, _sink) {
|
|
this._handleData = _handleData;
|
|
this._handleError = _handleError;
|
|
this._handleDone = _handleDone;
|
|
this._sink = _sink;
|
|
}
|
|
add(data) {
|
|
return this._handleData(data, this._sink);
|
|
}
|
|
addError(error, stackTrace) {
|
|
if (stackTrace === void 0)
|
|
stackTrace = null;
|
|
return this._handleError(error, stackTrace, this._sink);
|
|
}
|
|
close() {
|
|
return this._handleDone(this._sink);
|
|
}
|
|
}
|
|
return _HandlerEventSink;
|
|
});
|
|
let _HandlerEventSink = _HandlerEventSink$(dynamic, dynamic);
|
|
let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
|
|
class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
|
|
_StreamHandlerTransformer(opt$) {
|
|
let handleData = opt$.handleData === void 0 ? null : opt$.handleData;
|
|
let handleError = opt$.handleError === void 0 ? null : opt$.handleError;
|
|
let handleDone = opt$.handleDone === void 0 ? null : opt$.handleDone;
|
|
super._StreamSinkTransformer(dart.as((outputSink) => {
|
|
if (handleData === null)
|
|
handleData = _defaultHandleData;
|
|
if (handleError === null)
|
|
handleError = _defaultHandleError;
|
|
if (handleDone === null)
|
|
handleDone = _defaultHandleDone;
|
|
return new _HandlerEventSink(handleData, handleError, handleDone, outputSink);
|
|
}, _SinkMapper));
|
|
}
|
|
bind(stream) {
|
|
return super.bind(stream);
|
|
}
|
|
static _defaultHandleData(data, sink) {
|
|
sink.add(data);
|
|
}
|
|
static _defaultHandleError(error, stackTrace, sink) {
|
|
sink.addError(error);
|
|
}
|
|
static _defaultHandleDone(sink) {
|
|
sink.close();
|
|
}
|
|
}
|
|
return _StreamHandlerTransformer;
|
|
});
|
|
let _StreamHandlerTransformer = _StreamHandlerTransformer$(dynamic, dynamic);
|
|
let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
|
|
class _StreamSubscriptionTransformer extends dart.Object {
|
|
_StreamSubscriptionTransformer(_transformer) {
|
|
this._transformer = _transformer;
|
|
}
|
|
bind(stream) {
|
|
return new _BoundSubscriptionStream(stream, this._transformer);
|
|
}
|
|
}
|
|
return _StreamSubscriptionTransformer;
|
|
});
|
|
let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$(dynamic, dynamic);
|
|
let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
|
|
class _BoundSubscriptionStream extends Stream$(T) {
|
|
_BoundSubscriptionStream(_stream, _transformer) {
|
|
this._stream = _stream;
|
|
this._transformer = _transformer;
|
|
super.Stream();
|
|
}
|
|
listen(onData, opt$) {
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
|
|
let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
|
|
cancelOnError = core.identical(true, cancelOnError);
|
|
let result = this._transformer(this._stream, cancelOnError);
|
|
result.onData(onData);
|
|
result.onError(onError);
|
|
result.onDone(onDone);
|
|
return result;
|
|
}
|
|
}
|
|
return _BoundSubscriptionStream;
|
|
});
|
|
let _BoundSubscriptionStream = _BoundSubscriptionStream$(dynamic, dynamic);
|
|
class Timer extends dart.Object {
|
|
Timer(duration, callback) {
|
|
if (dart.equals(Zone.current, Zone.ROOT)) {
|
|
return Zone.current.createTimer(duration, callback);
|
|
}
|
|
return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
|
|
}
|
|
Timer$periodic(duration, callback) {
|
|
if (dart.equals(Zone.current, Zone.ROOT)) {
|
|
return Zone.current.createPeriodicTimer(duration, callback);
|
|
}
|
|
return Zone.current.createPeriodicTimer(duration, Zone.current.bindUnaryCallback(dart.as(callback, dart.throw_("Unimplemented type (dynamic) → dynamic")), {runGuarded: true}));
|
|
}
|
|
static run(callback) {
|
|
new Timer(core.Duration.ZERO, callback);
|
|
}
|
|
static _createTimer(duration, callback) {
|
|
let milliseconds = duration.inMilliseconds;
|
|
if (milliseconds < 0)
|
|
milliseconds = 0;
|
|
return dart.as(new TimerImpl(milliseconds, callback), Timer);
|
|
}
|
|
static _createPeriodicTimer(duration, callback) {
|
|
let milliseconds = duration.inMilliseconds;
|
|
if (milliseconds < 0)
|
|
milliseconds = 0;
|
|
return dart.as(new dart.dload(/* Unimplemented unknown name */TimerImpl, 'periodic')(milliseconds, callback), Timer);
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(Timer, 'periodic');
|
|
class AsyncError extends dart.Object {
|
|
AsyncError(error, stackTrace) {
|
|
this.error = error;
|
|
this.stackTrace = stackTrace;
|
|
}
|
|
toString() {
|
|
return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
|
|
}
|
|
}
|
|
class _ZoneFunction extends dart.Object {
|
|
_ZoneFunction(zone, function) {
|
|
this.zone = zone;
|
|
this["function"] = function;
|
|
}
|
|
}
|
|
class ZoneSpecification extends dart.Object {
|
|
ZoneSpecification(opt$) {
|
|
return new _ZoneSpecification(opt$);
|
|
}
|
|
ZoneSpecification$from(other, opt$) {
|
|
let handleUncaughtError = opt$.handleUncaughtError === void 0 ? null : opt$.handleUncaughtError;
|
|
let run = opt$.run === void 0 ? null : opt$.run;
|
|
let runUnary = opt$.runUnary === void 0 ? null : opt$.runUnary;
|
|
let runBinary = opt$.runBinary === void 0 ? null : opt$.runBinary;
|
|
let registerCallback = opt$.registerCallback === void 0 ? null : opt$.registerCallback;
|
|
let registerUnaryCallback = opt$.registerUnaryCallback === void 0 ? null : opt$.registerUnaryCallback;
|
|
let registerBinaryCallback = opt$.registerBinaryCallback === void 0 ? null : opt$.registerBinaryCallback;
|
|
let errorCallback = opt$.errorCallback === void 0 ? null : opt$.errorCallback;
|
|
let scheduleMicrotask = opt$.scheduleMicrotask === void 0 ? null : opt$.scheduleMicrotask;
|
|
let createTimer = opt$.createTimer === void 0 ? null : opt$.createTimer;
|
|
let createPeriodicTimer = opt$.createPeriodicTimer === void 0 ? null : opt$.createPeriodicTimer;
|
|
let print = opt$.print === void 0 ? null : opt$.print;
|
|
let fork = opt$.fork === void 0 ? null : opt$.fork;
|
|
return new ZoneSpecification({handleUncaughtError: handleUncaughtError !== null ? handleUncaughtError : other.handleUncaughtError, run: run !== null ? run : other.run, runUnary: runUnary !== null ? runUnary : other.runUnary, runBinary: runBinary !== null ? runBinary : other.runBinary, registerCallback: registerCallback !== null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback !== null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback !== null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback !== null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask !== null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer !== null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer !== null ? createPeriodicTimer : other.createPeriodicTimer, print: print !== null ? print : other.print, fork: fork !== null ? fork : other.fork});
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(ZoneSpecification, 'from');
|
|
class _ZoneSpecification extends dart.Object {
|
|
_ZoneSpecification(opt$) {
|
|
let handleUncaughtError = opt$.handleUncaughtError === void 0 ? null : opt$.handleUncaughtError;
|
|
let run = opt$.run === void 0 ? null : opt$.run;
|
|
let runUnary = opt$.runUnary === void 0 ? null : opt$.runUnary;
|
|
let runBinary = opt$.runBinary === void 0 ? null : opt$.runBinary;
|
|
let registerCallback = opt$.registerCallback === void 0 ? null : opt$.registerCallback;
|
|
let registerUnaryCallback = opt$.registerUnaryCallback === void 0 ? null : opt$.registerUnaryCallback;
|
|
let registerBinaryCallback = opt$.registerBinaryCallback === void 0 ? null : opt$.registerBinaryCallback;
|
|
let errorCallback = opt$.errorCallback === void 0 ? null : opt$.errorCallback;
|
|
let scheduleMicrotask = opt$.scheduleMicrotask === void 0 ? null : opt$.scheduleMicrotask;
|
|
let createTimer = opt$.createTimer === void 0 ? null : opt$.createTimer;
|
|
let createPeriodicTimer = opt$.createPeriodicTimer === void 0 ? null : opt$.createPeriodicTimer;
|
|
let print = opt$.print === void 0 ? null : opt$.print;
|
|
let fork = opt$.fork === void 0 ? null : opt$.fork;
|
|
this.handleUncaughtError = handleUncaughtError;
|
|
this.run = run;
|
|
this.runUnary = runUnary;
|
|
this.runBinary = runBinary;
|
|
this.registerCallback = registerCallback;
|
|
this.registerUnaryCallback = registerUnaryCallback;
|
|
this.registerBinaryCallback = registerBinaryCallback;
|
|
this.errorCallback = errorCallback;
|
|
this.scheduleMicrotask = scheduleMicrotask;
|
|
this.createTimer = createTimer;
|
|
this.createPeriodicTimer = createPeriodicTimer;
|
|
this.print = print;
|
|
this.fork = fork;
|
|
}
|
|
}
|
|
class ZoneDelegate extends dart.Object {
|
|
}
|
|
class Zone extends dart.Object {
|
|
Zone$_() {
|
|
}
|
|
static get current() {
|
|
return _current;
|
|
}
|
|
static _enter(zone) {
|
|
dart.assert(zone !== null);
|
|
dart.assert(!dart.notNull(core.identical(zone, _current)));
|
|
let previous = _current;
|
|
_current = zone;
|
|
return previous;
|
|
}
|
|
static _leave(previous) {
|
|
dart.assert(previous !== null);
|
|
Zone._current = previous;
|
|
}
|
|
}
|
|
dart.defineNamedConstructor(Zone, '_');
|
|
Zone.ROOT = dart.as(_ROOT_ZONE, Zone);
|
|
Zone._current = dart.as(_ROOT_ZONE, Zone);
|
|
// Function _parentDelegate: (_Zone) → ZoneDelegate
|
|
function _parentDelegate(zone) {
|
|
if (zone.parent === null)
|
|
return null;
|
|
return zone.parent._delegate;
|
|
}
|
|
class _ZoneDelegate extends dart.Object {
|
|
_ZoneDelegate(_delegationTarget) {
|
|
this._delegationTarget = _delegationTarget;
|
|
}
|
|
handleUncaughtError(zone, error, stackTrace) {
|
|
let implementation = this._delegationTarget._handleUncaughtError;
|
|
let implZone = implementation.zone;
|
|
return dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, error, stackTrace);
|
|
}
|
|
run(zone, f) {
|
|
let implementation = this._delegationTarget._run;
|
|
let implZone = implementation.zone;
|
|
return dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f);
|
|
}
|
|
runUnary(zone, f, arg) {
|
|
let implementation = this._delegationTarget._runUnary;
|
|
let implZone = implementation.zone;
|
|
return dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f, arg);
|
|
}
|
|
runBinary(zone, f, arg1, arg2) {
|
|
let implementation = this._delegationTarget._runBinary;
|
|
let implZone = implementation.zone;
|
|
return dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
|
|
}
|
|
registerCallback(zone, f) {
|
|
let implementation = this._delegationTarget._registerCallback;
|
|
let implZone = implementation.zone;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f), ZoneCallback);
|
|
}
|
|
registerUnaryCallback(zone, f) {
|
|
let implementation = this._delegationTarget._registerUnaryCallback;
|
|
let implZone = implementation.zone;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
|
|
}
|
|
registerBinaryCallback(zone, f) {
|
|
let implementation = this._delegationTarget._registerBinaryCallback;
|
|
let implZone = implementation.zone;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
|
|
}
|
|
errorCallback(zone, error, stackTrace) {
|
|
let implementation = this._delegationTarget._errorCallback;
|
|
let implZone = implementation.zone;
|
|
if (core.identical(implZone, _ROOT_ZONE))
|
|
return null;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
|
|
}
|
|
scheduleMicrotask(zone, f) {
|
|
let implementation = this._delegationTarget._scheduleMicrotask;
|
|
let implZone = implementation.zone;
|
|
dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, f);
|
|
}
|
|
createTimer(zone, duration, f) {
|
|
let implementation = this._delegationTarget._createTimer;
|
|
let implZone = implementation.zone;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, duration, f), Timer);
|
|
}
|
|
createPeriodicTimer(zone, period, f) {
|
|
let implementation = this._delegationTarget._createPeriodicTimer;
|
|
let implZone = implementation.zone;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, period, f), Timer);
|
|
}
|
|
print(zone, line) {
|
|
let implementation = this._delegationTarget._print;
|
|
let implZone = implementation.zone;
|
|
dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, line);
|
|
}
|
|
fork(zone, specification, zoneValues) {
|
|
let implementation = this._delegationTarget._fork;
|
|
let implZone = implementation.zone;
|
|
return dart.as(dart.dinvokef(implementation["function"], implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
|
|
}
|
|
}
|
|
class _Zone extends dart.Object {
|
|
_Zone() {
|
|
}
|
|
inSameErrorZone(otherZone) {
|
|
return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
|
|
}
|
|
}
|
|
class _CustomZone extends _Zone {
|
|
get _delegate() {
|
|
if (this._delegateCache !== null)
|
|
return this._delegateCache;
|
|
this._delegateCache = new _ZoneDelegate(this);
|
|
return this._delegateCache;
|
|
}
|
|
_CustomZone(parent, specification, _map) {
|
|
this.parent = parent;
|
|
this._map = _map;
|
|
this._runUnary = null;
|
|
this._run = null;
|
|
this._runBinary = null;
|
|
this._registerCallback = null;
|
|
this._registerUnaryCallback = null;
|
|
this._registerBinaryCallback = null;
|
|
this._errorCallback = null;
|
|
this._scheduleMicrotask = null;
|
|
this._createTimer = null;
|
|
this._createPeriodicTimer = null;
|
|
this._print = null;
|
|
this._fork = null;
|
|
this._handleUncaughtError = null;
|
|
this._delegateCache = null;
|
|
super._Zone();
|
|
this._run = specification.run !== null ? new _ZoneFunction(this, specification.run) : this.parent._run;
|
|
this._runUnary = specification.runUnary !== null ? new _ZoneFunction(this, specification.runUnary) : this.parent._runUnary;
|
|
this._runBinary = specification.runBinary !== null ? new _ZoneFunction(this, specification.runBinary) : this.parent._runBinary;
|
|
this._registerCallback = specification.registerCallback !== null ? new _ZoneFunction(this, specification.registerCallback) : this.parent._registerCallback;
|
|
this._registerUnaryCallback = specification.registerUnaryCallback !== null ? new _ZoneFunction(this, specification.registerUnaryCallback) : this.parent._registerUnaryCallback;
|
|
this._registerBinaryCallback = specification.registerBinaryCallback !== null ? new _ZoneFunction(this, specification.registerBinaryCallback) : this.parent._registerBinaryCallback;
|
|
this._errorCallback = specification.errorCallback !== null ? new _ZoneFunction(this, specification.errorCallback) : this.parent._errorCallback;
|
|
this._scheduleMicrotask = specification.scheduleMicrotask !== null ? new _ZoneFunction(this, specification.scheduleMicrotask) : this.parent._scheduleMicrotask;
|
|
this._createTimer = specification.createTimer !== null ? new _ZoneFunction(this, specification.createTimer) : this.parent._createTimer;
|
|
this._createPeriodicTimer = specification.createPeriodicTimer !== null ? new _ZoneFunction(this, specification.createPeriodicTimer) : this.parent._createPeriodicTimer;
|
|
this._print = specification.print !== null ? new _ZoneFunction(this, specification.print) : this.parent._print;
|
|
this._fork = specification.fork !== null ? new _ZoneFunction(this, specification.fork) : this.parent._fork;
|
|
this._handleUncaughtError = specification.handleUncaughtError !== null ? new _ZoneFunction(this, specification.handleUncaughtError) : this.parent._handleUncaughtError;
|
|
}
|
|
get errorZone() {
|
|
return this._handleUncaughtError.zone;
|
|
}
|
|
runGuarded(f) {
|
|
try {
|
|
return this.run(f);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
return this.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
runUnaryGuarded(f, arg) {
|
|
try {
|
|
return this.runUnary(f, arg);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
return this.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
runBinaryGuarded(f, arg1, arg2) {
|
|
try {
|
|
return this.runBinary(f, arg1, arg2);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
return this.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
bindCallback(f, opt$) {
|
|
let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
|
|
let registered = this.registerCallback(f);
|
|
if (runGuarded) {
|
|
return (() => this.runGuarded(registered)).bind(this);
|
|
} else {
|
|
return (() => this.run(registered)).bind(this);
|
|
}
|
|
}
|
|
bindUnaryCallback(f, opt$) {
|
|
let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
|
|
let registered = this.registerUnaryCallback(f);
|
|
if (runGuarded) {
|
|
return ((arg) => this.runUnaryGuarded(registered, arg)).bind(this);
|
|
} else {
|
|
return ((arg) => this.runUnary(registered, arg)).bind(this);
|
|
}
|
|
}
|
|
bindBinaryCallback(f, opt$) {
|
|
let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
|
|
let registered = this.registerBinaryCallback(f);
|
|
if (runGuarded) {
|
|
return ((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this);
|
|
} else {
|
|
return ((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this);
|
|
}
|
|
}
|
|
get(key) {
|
|
let result = this._map.get(key);
|
|
if (dart.notNull(result !== null) || dart.notNull(this._map.containsKey(key)))
|
|
return result;
|
|
if (this.parent !== null) {
|
|
let value = this.parent.get(key);
|
|
if (value !== null) {
|
|
this._map.set(key, value);
|
|
}
|
|
return value;
|
|
}
|
|
dart.assert(dart.equals(this, _ROOT_ZONE));
|
|
return null;
|
|
}
|
|
handleUncaughtError(error, stackTrace) {
|
|
let implementation = this._handleUncaughtError;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, error, stackTrace);
|
|
}
|
|
fork(opt$) {
|
|
let specification = opt$.specification === void 0 ? null : opt$.specification;
|
|
let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
|
|
let implementation = this._fork;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.as(dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, specification, zoneValues), Zone);
|
|
}
|
|
run(f) {
|
|
let implementation = this._run;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f);
|
|
}
|
|
runUnary(f, arg) {
|
|
let implementation = this._runUnary;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f, arg);
|
|
}
|
|
runBinary(f, arg1, arg2) {
|
|
let implementation = this._runBinary;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f, arg1, arg2);
|
|
}
|
|
registerCallback(f) {
|
|
let implementation = this._registerCallback;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.as(dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f), ZoneCallback);
|
|
}
|
|
registerUnaryCallback(f) {
|
|
let implementation = this._registerUnaryCallback;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.as(dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f), ZoneUnaryCallback);
|
|
}
|
|
registerBinaryCallback(f) {
|
|
let implementation = this._registerBinaryCallback;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.as(dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
|
|
}
|
|
errorCallback(error, stackTrace) {
|
|
let implementation = this._errorCallback;
|
|
dart.assert(implementation !== null);
|
|
let implementationZone = implementation.zone;
|
|
if (core.identical(implementationZone, _ROOT_ZONE))
|
|
return null;
|
|
let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
|
|
return dart.as(dart.dinvokef(implementation["function"], implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
|
|
}
|
|
scheduleMicrotask(f) {
|
|
let implementation = this._scheduleMicrotask;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, f);
|
|
}
|
|
createTimer(duration, f) {
|
|
let implementation = this._createTimer;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.as(dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, duration, f), Timer);
|
|
}
|
|
createPeriodicTimer(duration, f) {
|
|
let implementation = this._createPeriodicTimer;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.as(dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, duration, f), Timer);
|
|
}
|
|
print(line) {
|
|
let implementation = this._print;
|
|
dart.assert(implementation !== null);
|
|
let parentDelegate = _parentDelegate(implementation.zone);
|
|
return dart.dinvokef(implementation["function"], implementation.zone, parentDelegate, this, line);
|
|
}
|
|
}
|
|
// Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → void
|
|
function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
|
|
_schedulePriorityAsyncCallback(() => {
|
|
throw new _UncaughtAsyncError(error, stackTrace);
|
|
});
|
|
}
|
|
// Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
|
|
function _rootRun(self, parent, zone, f) {
|
|
if (dart.equals(Zone._current, zone))
|
|
return f();
|
|
let old = Zone._enter(zone);
|
|
try {
|
|
return f();
|
|
} finally {
|
|
Zone._leave(old);
|
|
}
|
|
}
|
|
// Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
|
|
function _rootRunUnary(self, parent, zone, f, arg) {
|
|
if (dart.equals(Zone._current, zone))
|
|
return f(arg);
|
|
let old = Zone._enter(zone);
|
|
try {
|
|
return f(arg);
|
|
} finally {
|
|
Zone._leave(old);
|
|
}
|
|
}
|
|
// Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
|
|
function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
|
|
if (dart.equals(Zone._current, zone))
|
|
return f(arg1, arg2);
|
|
let old = Zone._enter(zone);
|
|
try {
|
|
return f(arg1, arg2);
|
|
} finally {
|
|
Zone._leave(old);
|
|
}
|
|
}
|
|
// Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
|
|
function _rootRegisterCallback(self, parent, zone, f) {
|
|
return f;
|
|
}
|
|
// Function _rootRegisterUnaryCallback: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback
|
|
function _rootRegisterUnaryCallback(self, parent, zone, f) {
|
|
return f;
|
|
}
|
|
// Function _rootRegisterBinaryCallback: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic) → ZoneBinaryCallback
|
|
function _rootRegisterBinaryCallback(self, parent, zone, f) {
|
|
return f;
|
|
}
|
|
// Function _rootErrorCallback: (Zone, ZoneDelegate, Zone, Object, StackTrace) → AsyncError
|
|
function _rootErrorCallback(self, parent, zone, error, stackTrace) {
|
|
return null;
|
|
}
|
|
// Function _rootScheduleMicrotask: (Zone, ZoneDelegate, Zone, () → dynamic) → void
|
|
function _rootScheduleMicrotask(self, parent, zone, f) {
|
|
if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
|
|
let hasErrorHandler = dart.throw_("Unimplemented PrefixExpression: !_ROOT_ZONE.inSameErrorZone(zone)");
|
|
f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
|
|
}
|
|
_scheduleAsyncCallback(f);
|
|
}
|
|
// Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
|
|
function _rootCreateTimer(self, parent, zone, duration, callback) {
|
|
if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
|
|
callback = zone.bindCallback(callback);
|
|
}
|
|
return Timer._createTimer(duration, callback);
|
|
}
|
|
// Function _rootCreatePeriodicTimer: (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer
|
|
function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
|
|
if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
|
|
callback = zone.bindUnaryCallback(dart.as(callback, dart.throw_("Unimplemented type (dynamic) → dynamic")));
|
|
}
|
|
return Timer._createPeriodicTimer(duration, callback);
|
|
}
|
|
// Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
|
|
function _rootPrint(self, parent, zone, line) {
|
|
_internal.printToConsole(line);
|
|
}
|
|
// Function _printToZone: (String) → void
|
|
function _printToZone(line) {
|
|
Zone.current.print(line);
|
|
}
|
|
// Function _rootFork: (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zone
|
|
function _rootFork(self, parent, zone, specification, zoneValues) {
|
|
_internal.printToZone = _printToZone;
|
|
if (specification === null) {
|
|
specification = new ZoneSpecification();
|
|
} else if (!dart.is(specification, _ZoneSpecification)) {
|
|
throw new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor.");
|
|
}
|
|
let valueMap = null;
|
|
if (zoneValues === null) {
|
|
if (dart.is(zone, _Zone)) {
|
|
valueMap = zone._map;
|
|
} else {
|
|
valueMap = new collection.HashMap();
|
|
}
|
|
} else {
|
|
valueMap = new collection.HashMap.from(zoneValues);
|
|
}
|
|
return new _CustomZone(zone, specification, valueMap);
|
|
}
|
|
class _RootZoneSpecification extends dart.Object {
|
|
get handleUncaughtError() {
|
|
return _rootHandleUncaughtError;
|
|
}
|
|
get run() {
|
|
return _rootRun;
|
|
}
|
|
get runUnary() {
|
|
return _rootRunUnary;
|
|
}
|
|
get runBinary() {
|
|
return _rootRunBinary;
|
|
}
|
|
get registerCallback() {
|
|
return _rootRegisterCallback;
|
|
}
|
|
get registerUnaryCallback() {
|
|
return _rootRegisterUnaryCallback;
|
|
}
|
|
get registerBinaryCallback() {
|
|
return _rootRegisterBinaryCallback;
|
|
}
|
|
get errorCallback() {
|
|
return _rootErrorCallback;
|
|
}
|
|
get scheduleMicrotask() {
|
|
return _rootScheduleMicrotask;
|
|
}
|
|
get createTimer() {
|
|
return _rootCreateTimer;
|
|
}
|
|
get createPeriodicTimer() {
|
|
return _rootCreatePeriodicTimer;
|
|
}
|
|
get print() {
|
|
return _rootPrint;
|
|
}
|
|
get fork() {
|
|
return _rootFork;
|
|
}
|
|
}
|
|
class _RootZone extends _Zone {
|
|
_RootZone() {
|
|
super._Zone();
|
|
}
|
|
get _run() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootRun);
|
|
}
|
|
get _runUnary() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
|
|
}
|
|
get _runBinary() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootRunBinary);
|
|
}
|
|
get _registerCallback() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback);
|
|
}
|
|
get _registerUnaryCallback() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback);
|
|
}
|
|
get _registerBinaryCallback() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback);
|
|
}
|
|
get _errorCallback() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback);
|
|
}
|
|
get _scheduleMicrotask() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask);
|
|
}
|
|
get _createTimer() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
|
|
}
|
|
get _createPeriodicTimer() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
|
|
}
|
|
get _print() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootPrint);
|
|
}
|
|
get _fork() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootFork);
|
|
}
|
|
get _handleUncaughtError() {
|
|
return new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
|
|
}
|
|
get parent() {
|
|
return null;
|
|
}
|
|
get _map() {
|
|
return _rootMap;
|
|
}
|
|
get _delegate() {
|
|
if (_rootDelegate !== null)
|
|
return _rootDelegate;
|
|
return _rootDelegate = new _ZoneDelegate(this);
|
|
}
|
|
get errorZone() {
|
|
return this;
|
|
}
|
|
runGuarded(f) {
|
|
try {
|
|
if (core.identical(_ROOT_ZONE, Zone._current)) {
|
|
return f();
|
|
}
|
|
return _rootRun(null, null, this, f);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
return this.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
runUnaryGuarded(f, arg) {
|
|
try {
|
|
if (core.identical(_ROOT_ZONE, Zone._current)) {
|
|
return f(arg);
|
|
}
|
|
return _rootRunUnary(null, null, this, f, arg);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
return this.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
runBinaryGuarded(f, arg1, arg2) {
|
|
try {
|
|
if (core.identical(_ROOT_ZONE, Zone._current)) {
|
|
return f(arg1, arg2);
|
|
}
|
|
return _rootRunBinary(null, null, this, f, arg1, arg2);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
return this.handleUncaughtError(e, s);
|
|
}
|
|
|
|
}
|
|
bindCallback(f, opt$) {
|
|
let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
|
|
if (runGuarded) {
|
|
return (() => this.runGuarded(f)).bind(this);
|
|
} else {
|
|
return (() => this.run(f)).bind(this);
|
|
}
|
|
}
|
|
bindUnaryCallback(f, opt$) {
|
|
let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
|
|
if (runGuarded) {
|
|
return ((arg) => this.runUnaryGuarded(f, arg)).bind(this);
|
|
} else {
|
|
return ((arg) => this.runUnary(f, arg)).bind(this);
|
|
}
|
|
}
|
|
bindBinaryCallback(f, opt$) {
|
|
let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
|
|
if (runGuarded) {
|
|
return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this);
|
|
} else {
|
|
return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
|
|
}
|
|
}
|
|
get(key) {
|
|
return null;
|
|
}
|
|
handleUncaughtError(error, stackTrace) {
|
|
return _rootHandleUncaughtError(null, null, this, error, stackTrace);
|
|
}
|
|
fork(opt$) {
|
|
let specification = opt$.specification === void 0 ? null : opt$.specification;
|
|
let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
|
|
return _rootFork(null, null, this, specification, zoneValues);
|
|
}
|
|
run(f) {
|
|
if (core.identical(Zone._current, _ROOT_ZONE))
|
|
return f();
|
|
return _rootRun(null, null, this, f);
|
|
}
|
|
runUnary(f, arg) {
|
|
if (core.identical(Zone._current, _ROOT_ZONE))
|
|
return f(arg);
|
|
return _rootRunUnary(null, null, this, f, arg);
|
|
}
|
|
runBinary(f, arg1, arg2) {
|
|
if (core.identical(Zone._current, _ROOT_ZONE))
|
|
return f(arg1, arg2);
|
|
return _rootRunBinary(null, null, this, f, arg1, arg2);
|
|
}
|
|
registerCallback(f) {
|
|
return f;
|
|
}
|
|
registerUnaryCallback(f) {
|
|
return f;
|
|
}
|
|
registerBinaryCallback(f) {
|
|
return f;
|
|
}
|
|
errorCallback(error, stackTrace) {
|
|
return null;
|
|
}
|
|
scheduleMicrotask(f) {
|
|
_rootScheduleMicrotask(null, null, this, f);
|
|
}
|
|
createTimer(duration, f) {
|
|
return Timer._createTimer(duration, f);
|
|
}
|
|
createPeriodicTimer(duration, f) {
|
|
return Timer._createPeriodicTimer(duration, f);
|
|
}
|
|
print(line) {
|
|
_internal.printToConsole(line);
|
|
}
|
|
}
|
|
_RootZone._rootDelegate = null;
|
|
dart.defineLazyProperties(_RootZone, {
|
|
get _rootMap() {
|
|
return new collection.HashMap();
|
|
},
|
|
set _rootMap() {}
|
|
});
|
|
let _ROOT_ZONE = new _RootZone();
|
|
// Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneSpecification: ZoneSpecification, onError: Function}) → dynamic
|
|
function runZoned(body, opt$) {
|
|
let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
|
|
let zoneSpecification = opt$.zoneSpecification === void 0 ? null : opt$.zoneSpecification;
|
|
let onError = opt$.onError === void 0 ? null : opt$.onError;
|
|
let errorHandler = null;
|
|
if (onError !== null) {
|
|
errorHandler = (self, parent, zone, error, stackTrace) => {
|
|
try {
|
|
if (dart.is(onError, ZoneBinaryCallback)) {
|
|
return self.parent.runBinary(onError, error, stackTrace);
|
|
}
|
|
return self.parent.runUnary(dart.as(onError, dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
|
|
} catch (e) {
|
|
let s = dart.stackTrace(e);
|
|
if (core.identical(e, error)) {
|
|
return parent.handleUncaughtError(zone, error, stackTrace);
|
|
} else {
|
|
return parent.handleUncaughtError(zone, e, s);
|
|
}
|
|
}
|
|
|
|
};
|
|
}
|
|
if (zoneSpecification === null) {
|
|
zoneSpecification = new ZoneSpecification({handleUncaughtError: errorHandler});
|
|
} else if (errorHandler !== null) {
|
|
zoneSpecification = new ZoneSpecification.from(zoneSpecification, {handleUncaughtError: errorHandler});
|
|
}
|
|
let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
|
|
if (onError !== null) {
|
|
return zone.runGuarded(body);
|
|
} else {
|
|
return zone.run(body);
|
|
}
|
|
}
|
|
// Exports:
|
|
async.DeferredLibrary = DeferredLibrary;
|
|
async.DeferredLoadException = DeferredLoadException;
|
|
async.Future = Future;
|
|
async.Future$ = Future$;
|
|
async.TimeoutException = TimeoutException;
|
|
async.Completer = Completer;
|
|
async.Completer$ = Completer$;
|
|
async.scheduleMicrotask = scheduleMicrotask;
|
|
async.Stream = Stream;
|
|
async.Stream$ = Stream$;
|
|
async.StreamSubscription = StreamSubscription;
|
|
async.StreamSubscription$ = StreamSubscription$;
|
|
async.EventSink = EventSink;
|
|
async.EventSink$ = EventSink$;
|
|
async.StreamView = StreamView;
|
|
async.StreamView$ = StreamView$;
|
|
async.StreamConsumer = StreamConsumer;
|
|
async.StreamConsumer$ = StreamConsumer$;
|
|
async.StreamSink = StreamSink;
|
|
async.StreamSink$ = StreamSink$;
|
|
async.StreamTransformer = StreamTransformer;
|
|
async.StreamTransformer$ = StreamTransformer$;
|
|
async.StreamIterator = StreamIterator;
|
|
async.StreamIterator$ = StreamIterator$;
|
|
async.StreamController = StreamController;
|
|
async.StreamController$ = StreamController$;
|
|
async.Timer = Timer;
|
|
async.AsyncError = AsyncError;
|
|
async.ZoneSpecification = ZoneSpecification;
|
|
async.ZoneDelegate = ZoneDelegate;
|
|
async.Zone = Zone;
|
|
async.runZoned = runZoned;
|
|
})(async || (async = {}));
|