constructor(underlyingSink: Sink<T> = {}, strategy: Strategy<T> = {}) {
this._underlyingSink = underlyingSink;
this._closedPromise = new Promise<void>((resolve, reject) => {
this._resolveClosedPromise = resolve;
this._rejectClosedPromise = reject;
});
this._closedPromise.catch(() => {});
this._advancing = false;
this._readyPromise = Promise.resolve();
this._queue = new SizeQueue<Record<T>>();
this._state = State.Writable;
this._started = false;
this._writing = false;
this._strategy = util.normalizeStrategy(strategy);
this._syncStateWithQueue();
this._startedPromise = Promise.resolve(
util.invokeOrNoop(this._underlyingSink, 'start', [ this._error.bind(this) ])
).then(() => {
this._started = true;
this._startedPromise = undefined;
}, (error: Error) => {
this._error(error);
});
}
start(): Promise<void> {
if (this._isClosed) {
return Promise.reject(new Error('Stream is closed'));
}
return Promise.resolve();
}
/**
* Signals that the producer can no longer write to the stream and it should be immediately moved to an "errored"
* state. Any un-written data that is queued will be discarded.
*/
abort(reason: any): Promise<void> {
// 4.2.4.4-1
if (!isWritableStream(this)) {
return Promise.reject(
new Error('WritableStream method called in context of object that is not a WritableStream instance')
);
}
if (this.state === State.Closed) {
// 4.2.4.4-2
return Promise.resolve();
}
if (this.state === State.Errored) {
// 4.2.4.4-3
return Promise.reject(this._storedError);
}
const error: Error = reason instanceof Error ? reason : new Error(reason);
this._error(error);
return util.promiseInvokeOrFallbackOrNoop(this._underlyingSink, 'abort', [ reason ], 'close')
.then(function () {
return;
});
}
function catchRejection(router: Router<Context>, context: Context, path: string, thenable: void | Thenable<any>) {
if (thenable) {
Promise.resolve(thenable).catch((error) => {
reportError(router, context, path, error);
});
}
}
return this.reader.read().then((result: ReadResult<T>) => {
if (result.done || this.reader.currentPosition === position) {
return Promise.resolve(this.reader.currentPosition);
}
else {
return discardNext();
}
});
return reader.read().then(function (result: ReadResult<number>) {
if (result.done) {
return Promise.resolve();
}
else {
results.push(result.value);
return readNext();
}
});
return pluginLoad(moduleIds, load, (moduleIds: string[]) => {
try {
return Promise.resolve(moduleIds.map(function (moduleId): any {
return contextualRequire(moduleId.split('!')[0]);
}));
}
catch (error) {
return Promise.reject(error);
}
});
seek(controller: ReadableStreamController<T>, position: number): Promise<number> {
if (position >= this.data.length || position < 0) {
let error = new Error('Invalid seek position: ' + position);
controller.error(error);
return Promise.reject(error);
}
this.currentPosition = position;
return Promise.resolve(this.currentPosition);
}
import Promise from '@dojo/shim/Promise';
import { Source } from './ReadableStream';
import ReadableStreamController from './ReadableStreamController';
const resolved = Promise.resolve();
/**
* A seekable array source
*/
export default class ArraySource<T> implements Source<T> {
// current seek position in the data array
currentPosition: number;
// shallow copy of data array passed to constructor
data: Array<T>;
constructor(data: Array<T>) {
this.currentPosition = 0;
this.data = [];
if (data && data.length) {
this.data = this.data.concat(data);
}
}
seek(controller: ReadableStreamController<T>, position: number): Promise<number> {
if (position >= this.data.length || position < 0) {
let error = new Error('Invalid seek position: ' + position);
controller.error(error);
return Promise.reject(error);
write(chunk: string): Promise<void> {
return Promise.resolve();
}
