How to use defaultWriterReadyPromiseReject method in wpt

Best JavaScript code snippet using wpt

writable-stream.ts

Source:writable-stream.ts

...540  }541}542function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer: WritableStreamDefaultWriter<any>, error: any) {543  if (writer._readyPromiseState === 'pending') {544    defaultWriterReadyPromiseReject(writer, error);545  } else {546    defaultWriterReadyPromiseResetToRejected(writer, error);547  }548}549function WritableStreamDefaultWriterGetDesiredSize(writer: WritableStreamDefaultWriter<any>): number | null {550  const stream = writer._ownerWritableStream;551  const state = stream._state;552  if (state === 'errored' || state === 'erroring') {553    return null;554  }555  if (state === 'closed') {556    return 0;557  }558  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);559}560function WritableStreamDefaultWriterRelease(writer: WritableStreamDefaultWriter<any>) {561  const stream = writer._ownerWritableStream;562  assert(stream !== undefined);563  assert(stream._writer === writer);564  const releasedError = new TypeError(565    'Writer was released and can no longer be used to monitor the stream\'s closedness');566  WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);567  // The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not568  // rejected until afterwards. This means that simply testing state will not work.569  WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);570  stream._writer = undefined;571  writer._ownerWritableStream = undefined!;572}573function WritableStreamDefaultWriterWrite<W>(writer: WritableStreamDefaultWriter<W>, chunk: W): Promise<void> {574  const stream = writer._ownerWritableStream;575  assert(stream !== undefined);576  const controller = stream._writableStreamController;577  const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);578  if (stream !== writer._ownerWritableStream) {579    return Promise.reject(defaultWriterLockException('write to'));580  }581  const state = stream._state;582  if (state === 'errored') {583    return Promise.reject(stream._storedError);584  }585  if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {586    return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));587  }588  if (state === 'erroring') {589    return Promise.reject(stream._storedError);590  }591  assert(state === 'writable');592  const promise = WritableStreamAddWriteRequest(stream);593  WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);594  return promise;595}596interface WriteRecord<W> {597  chunk: W;598}599type QueueRecord<W> = WriteRecord<W> | 'close';600export type WritableStreamDefaultControllerType = WritableStreamDefaultController<any>;601class WritableStreamDefaultController<W = any> {602  /** @internal */603  _controlledWritableStream!: WritableStream<W>;604  /** @internal */605  _queue!: SimpleQueue<QueuePair<QueueRecord<W>>>;606  /** @internal */607  _queueTotalSize!: number;608  /** @internal */609  _started!: boolean;610  /** @internal */611  _strategySizeAlgorithm!: QueuingStrategySizeCallback<W>;612  /** @internal */613  _strategyHWM!: number;614  /** @internal */615  _writeAlgorithm!: (chunk: W) => Promise<void>;616  /** @internal */617  _closeAlgorithm!: () => Promise<void>;618  /** @internal */619  _abortAlgorithm!: (reason: any) => Promise<void>;620  /** @internal */621  constructor() {622    throw new TypeError('WritableStreamDefaultController cannot be constructed explicitly');623  }624  error(e: any) {625    if (IsWritableStreamDefaultController(this) === false) {626      throw new TypeError(627        'WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');628    }629    const state = this._controlledWritableStream._state;630    if (state !== 'writable') {631      // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so632      // just treat it as a no-op.633      return;634    }635    WritableStreamDefaultControllerError(this, e);636  }637  /** @internal */638  [AbortSteps](reason: any) {639    const result = this._abortAlgorithm(reason);640    WritableStreamDefaultControllerClearAlgorithms(this);641    return result;642  }643  /** @internal */644  [ErrorSteps]() {645    ResetQueue(this);646  }647}648// Abstract operations implementing interface required by the WritableStream.649function IsWritableStreamDefaultController<W>(x: any): x is WritableStreamDefaultController<W> {650  if (!typeIsObject(x)) {651    return false;652  }653  if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {654    return false;655  }656  return true;657}658function SetUpWritableStreamDefaultController<W>(stream: WritableStream<W>,659                                                 controller: WritableStreamDefaultController<W>,660                                                 startAlgorithm: () => void | PromiseLike<void>,661                                                 writeAlgorithm: (chunk: W) => Promise<void>,662                                                 closeAlgorithm: () => Promise<void>,663                                                 abortAlgorithm: (reason: any) => Promise<void>,664                                                 highWaterMark: number,665                                                 sizeAlgorithm: QueuingStrategySizeCallback<W>) {666  assert(IsWritableStream(stream) === true);667  assert(stream._writableStreamController === undefined);668  controller._controlledWritableStream = stream;669  stream._writableStreamController = controller;670  // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.671  controller._queue = undefined!;672  controller._queueTotalSize = undefined!;673  ResetQueue(controller);674  controller._started = false;675  controller._strategySizeAlgorithm = sizeAlgorithm;676  controller._strategyHWM = highWaterMark;677  controller._writeAlgorithm = writeAlgorithm;678  controller._closeAlgorithm = closeAlgorithm;679  controller._abortAlgorithm = abortAlgorithm;680  const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);681  WritableStreamUpdateBackpressure(stream, backpressure);682  const startResult = startAlgorithm();683  const startPromise = Promise.resolve(startResult);684  startPromise.then(685    () => {686      assert(stream._state === 'writable' || stream._state === 'erroring');687      controller._started = true;688      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);689    },690    r => {691      assert(stream._state === 'writable' || stream._state === 'erroring');692      controller._started = true;693      WritableStreamDealWithRejection(stream, r);694    }695  ).catch(rethrowAssertionErrorRejection);696}697function SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(stream: WritableStream<W>,698                                                                   underlyingSink: UnderlyingSink<W>,699                                                                   highWaterMark: number,700                                                                   sizeAlgorithm: QueuingStrategySizeCallback<W>) {701  assert(underlyingSink !== undefined);702  const controller = Object.create(WritableStreamDefaultController.prototype);703  function startAlgorithm() {704    return InvokeOrNoop<typeof underlyingSink, 'start'>(underlyingSink, 'start', [controller]);705  }706  const writeAlgorithm = CreateAlgorithmFromUnderlyingMethod<typeof underlyingSink, 'write'>(707    underlyingSink, 'write', 1, [controller]708  );709  const closeAlgorithm = CreateAlgorithmFromUnderlyingMethod<typeof underlyingSink, 'close'>(710    underlyingSink, 'close', 0, []711  );712  const abortAlgorithm = CreateAlgorithmFromUnderlyingMethod<typeof underlyingSink, 'abort'>(713    underlyingSink, 'abort', 1, []714  );715  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,716                                       abortAlgorithm, highWaterMark, sizeAlgorithm);717}718// ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.719function WritableStreamDefaultControllerClearAlgorithms(controller: WritableStreamDefaultController<any>) {720  controller._writeAlgorithm = undefined!;721  controller._closeAlgorithm = undefined!;722  controller._abortAlgorithm = undefined!;723  controller._strategySizeAlgorithm = undefined!;724}725function WritableStreamDefaultControllerClose(controller: WritableStreamDefaultController<any>) {726  EnqueueValueWithSize(controller, 'close', 0);727  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);728}729function WritableStreamDefaultControllerGetChunkSize<W>(controller: WritableStreamDefaultController<W>,730                                                        chunk: W): number {731  try {732    return controller._strategySizeAlgorithm(chunk);733  } catch (chunkSizeE) {734    WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);735    return 1;736  }737}738function WritableStreamDefaultControllerGetDesiredSize(controller: WritableStreamDefaultController<any>): number {739  return controller._strategyHWM - controller._queueTotalSize;740}741function WritableStreamDefaultControllerWrite<W>(controller: WritableStreamDefaultController<W>,742                                                 chunk: W,743                                                 chunkSize: number) {744  const writeRecord = { chunk };745  try {746    EnqueueValueWithSize(controller, writeRecord, chunkSize);747  } catch (enqueueE) {748    WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);749    return;750  }751  const stream = controller._controlledWritableStream;752  if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {753    const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);754    WritableStreamUpdateBackpressure(stream, backpressure);755  }756  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);757}758// Abstract operations for the WritableStreamDefaultController.759function WritableStreamDefaultControllerAdvanceQueueIfNeeded<W>(controller: WritableStreamDefaultController<W>) {760  const stream = controller._controlledWritableStream;761  if (controller._started === false) {762    return;763  }764  if (stream._inFlightWriteRequest !== undefined) {765    return;766  }767  const state = stream._state;768  assert(state !== 'closed' && state !== 'errored');769  if (state === 'erroring') {770    WritableStreamFinishErroring(stream);771    return;772  }773  if (controller._queue.length === 0) {774    return;775  }776  const writeRecord = PeekQueueValue(controller);777  if (writeRecord === 'close') {778    WritableStreamDefaultControllerProcessClose(controller);779  } else {780    WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);781  }782}783function WritableStreamDefaultControllerErrorIfNeeded(controller: WritableStreamDefaultController<any>, error: any) {784  if (controller._controlledWritableStream._state === 'writable') {785    WritableStreamDefaultControllerError(controller, error);786  }787}788function WritableStreamDefaultControllerProcessClose(controller: WritableStreamDefaultController<any>) {789  const stream = controller._controlledWritableStream;790  WritableStreamMarkCloseRequestInFlight(stream);791  DequeueValue(controller);792  assert(controller._queue.length === 0);793  const sinkClosePromise = controller._closeAlgorithm();794  WritableStreamDefaultControllerClearAlgorithms(controller);795  sinkClosePromise.then(796    () => {797      WritableStreamFinishInFlightClose(stream);798    },799    reason => {800      WritableStreamFinishInFlightCloseWithError(stream, reason);801    }802  ).catch(rethrowAssertionErrorRejection);803}804function WritableStreamDefaultControllerProcessWrite<W>(controller: WritableStreamDefaultController<W>, chunk: W) {805  const stream = controller._controlledWritableStream;806  WritableStreamMarkFirstWriteRequestInFlight(stream);807  const sinkWritePromise = controller._writeAlgorithm(chunk);808  sinkWritePromise.then(809    () => {810      WritableStreamFinishInFlightWrite(stream);811      const state = stream._state;812      assert(state === 'writable' || state === 'erroring');813      DequeueValue(controller);814      if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {815        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);816        WritableStreamUpdateBackpressure(stream, backpressure);817      }818      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);819    },820    reason => {821      if (stream._state === 'writable') {822        WritableStreamDefaultControllerClearAlgorithms(controller);823      }824      WritableStreamFinishInFlightWriteWithError(stream, reason);825    }826  ).catch(rethrowAssertionErrorRejection);827}828function WritableStreamDefaultControllerGetBackpressure(controller: WritableStreamDefaultController<any>): boolean {829  const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);830  return desiredSize <= 0;831}832// A client of WritableStreamDefaultController may use these functions directly to bypass state check.833function WritableStreamDefaultControllerError(controller: WritableStreamDefaultController<any>, error: any) {834  const stream = controller._controlledWritableStream;835  assert(stream._state === 'writable');836  WritableStreamDefaultControllerClearAlgorithms(controller);837  WritableStreamStartErroring(stream, error);838}839// Helper functions for the WritableStream.840function streamBrandCheckException(name: string): TypeError {841  return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);842}843// Helper functions for the WritableStreamDefaultWriter.844function defaultWriterBrandCheckException(name: string): TypeError {845  return new TypeError(846    `WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);847}848function defaultWriterLockException(name: string): TypeError {849  return new TypeError('Cannot ' + name + ' a stream using a released writer');850}851function defaultWriterClosedPromiseInitialize(writer: WritableStreamDefaultWriter<any>) {852  writer._closedPromise = new Promise((resolve, reject) => {853    writer._closedPromise_resolve = resolve;854    writer._closedPromise_reject = reject;855    writer._closedPromiseState = 'pending';856  });857}858function defaultWriterClosedPromiseInitializeAsRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {859  defaultWriterClosedPromiseInitialize(writer);860  defaultWriterClosedPromiseReject(writer, reason);861}862function defaultWriterClosedPromiseInitializeAsResolved(writer: WritableStreamDefaultWriter<any>) {863  defaultWriterClosedPromiseInitialize(writer);864  defaultWriterClosedPromiseResolve(writer);865}866function defaultWriterClosedPromiseReject(writer: WritableStreamDefaultWriter<any>, reason: any) {867  assert(writer._closedPromise_resolve !== undefined);868  assert(writer._closedPromise_reject !== undefined);869  assert(writer._closedPromiseState === 'pending');870  writer._closedPromise.catch(() => {});871  writer._closedPromise_reject!(reason);872  writer._closedPromise_resolve = undefined;873  writer._closedPromise_reject = undefined;874  writer._closedPromiseState = 'rejected';875}876function defaultWriterClosedPromiseResetToRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {877  assert(writer._closedPromise_resolve === undefined);878  assert(writer._closedPromise_reject === undefined);879  assert(writer._closedPromiseState !== 'pending');880  defaultWriterClosedPromiseInitializeAsRejected(writer, reason);881}882function defaultWriterClosedPromiseResolve(writer: WritableStreamDefaultWriter<any>) {883  assert(writer._closedPromise_resolve !== undefined);884  assert(writer._closedPromise_reject !== undefined);885  assert(writer._closedPromiseState === 'pending');886  writer._closedPromise_resolve!(undefined);887  writer._closedPromise_resolve = undefined;888  writer._closedPromise_reject = undefined;889  writer._closedPromiseState = 'resolved';890}891function defaultWriterReadyPromiseInitialize(writer: WritableStreamDefaultWriter<any>) {892  writer._readyPromise = new Promise((resolve, reject) => {893    writer._readyPromise_resolve = resolve;894    writer._readyPromise_reject = reject;895  });896  writer._readyPromiseState = 'pending';897}898function defaultWriterReadyPromiseInitializeAsRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {899  defaultWriterReadyPromiseInitialize(writer);900  defaultWriterReadyPromiseReject(writer, reason);901}902function defaultWriterReadyPromiseInitializeAsResolved(writer: WritableStreamDefaultWriter<any>) {903  defaultWriterReadyPromiseInitialize(writer);904  defaultWriterReadyPromiseResolve(writer);905}906function defaultWriterReadyPromiseReject(writer: WritableStreamDefaultWriter<any>, reason: any) {907  assert(writer._readyPromise_resolve !== undefined);908  assert(writer._readyPromise_reject !== undefined);909  writer._readyPromise.catch(() => {});910  writer._readyPromise_reject!(reason);911  writer._readyPromise_resolve = undefined;912  writer._readyPromise_reject = undefined;913  writer._readyPromiseState = 'rejected';914}915function defaultWriterReadyPromiseReset(writer: WritableStreamDefaultWriter<any>) {916  assert(writer._readyPromise_resolve === undefined);917  assert(writer._readyPromise_reject === undefined);918  defaultWriterReadyPromiseInitialize(writer);919}920function defaultWriterReadyPromiseResetToRejected(writer: WritableStreamDefaultWriter<any>, reason: any) {...

writable-stream.js

Source:writable-stream.js

...112    defaultWriterClosedPromiseReject(writer, e);113    writer._closedPromise.catch(() => {});114    if (state === 'writable' &&115        WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {116      defaultWriterReadyPromiseReject(writer, e);117    } else {118      defaultWriterReadyPromiseResetToRejected(writer, e);119    }120    writer._readyPromise.catch(() => {});121  }122  stream._state = 'errored';123  stream._storedError = e;124}125function WritableStreamFinishClose(stream) {126  assert(stream._state === 'closing');127  // writer cannot be released while close() is ongoing. So, we can assert that128  // there's an active writer.129  assert(stream._writer !== undefined);130  stream._state = 'closed';131  defaultWriterClosedPromiseResolve(stream._writer);132}133function WritableStreamFulfillWriteRequest(stream) {134  assert(stream._writeRequests.length > 0);135  const writeRequest = stream._writeRequests.shift();136  writeRequest._resolve(undefined);137}138function WritableStreamUpdateBackpressure(stream, backpressure) {139  assert(stream._state === 'writable');140  const writer = stream._writer;141  if (writer === undefined) {142    return;143  }144  if (backpressure === true) {145    defaultWriterReadyPromiseReset(writer);146  } else {147    assert(backpressure === false);148    defaultWriterReadyPromiseResolve(writer);149  }150}151class WritableStreamDefaultWriter {152  constructor(stream) {153    if (IsWritableStream(stream) === false) {154      throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance');155    }156    if (IsWritableStreamLocked(stream) === true) {157      throw new TypeError('This stream has already been locked for exclusive writing by another writer');158    }159    this._ownerWritableStream = stream;160    stream._writer = this;161    const state = stream._state;162    if (state === 'writable' || state === 'closing') {163      defaultWriterClosedPromiseInitialize(this);164    } else if (state === 'closed') {165      defaultWriterClosedPromiseInitializeAsResolved(this);166    } else {167      assert(state === 'errored', 'state must be errored');168      defaultWriterClosedPromiseInitializeAsRejected(this, stream._storedError);169      this._closedPromise.catch(() => {});170    }171    if (state === 'writable' &&172        WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {173      defaultWriterReadyPromiseInitialize(this);174    } else {175      defaultWriterReadyPromiseInitializeAsResolved(this, undefined);176    }177  }178  get closed() {179    if (IsWritableStreamDefaultWriter(this) === false) {180      return Promise.reject(defaultWriterBrandCheckException('closed'));181    }182    return this._closedPromise;183  }184  get desiredSize() {185    if (IsWritableStreamDefaultWriter(this) === false) {186      throw defaultWriterBrandCheckException('desiredSize');187    }188    if (this._ownerWritableStream === undefined) {189      throw defaultWriterLockException('desiredSize');190    }191    return WritableStreamDefaultWriterGetDesiredSize(this);192  }193  get ready() {194    if (IsWritableStreamDefaultWriter(this) === false) {195      return Promise.reject(defaultWriterBrandCheckException('ready'));196    }197    return this._readyPromise;198  }199  abort(reason) {200    if (IsWritableStreamDefaultWriter(this) === false) {201      return Promise.reject(defaultWriterBrandCheckException('abort'));202    }203    if (this._ownerWritableStream === undefined) {204      return Promise.reject(defaultWriterLockException('abort'));205    }206    return WritableStreamDefaultWriterAbort(this, reason);207  }208  close() {209    if (IsWritableStreamDefaultWriter(this) === false) {210      return Promise.reject(defaultWriterBrandCheckException('close'));211    }212    const stream = this._ownerWritableStream;213    if (stream === undefined) {214      return Promise.reject(defaultWriterLockException('close'));215    }216    if (stream._state === 'closing') {217      return Promise.reject(new TypeError('cannot close an already-closing stream'));218    }219    return WritableStreamDefaultWriterClose(this);220  }221  releaseLock() {222    if (IsWritableStreamDefaultWriter(this) === false) {223      throw defaultWriterBrandCheckException('releaseLock');224    }225    const stream = this._ownerWritableStream;226    if (stream === undefined) {227      return;228    }229    assert(stream._writer !== undefined);230    WritableStreamDefaultWriterRelease(this);231  }232  write(chunk) {233    if (IsWritableStreamDefaultWriter(this) === false) {234      return Promise.reject(defaultWriterBrandCheckException('write'));235    }236    const stream = this._ownerWritableStream;237    if (stream === undefined) {238      return Promise.reject(defaultWriterLockException('write to'));239    }240    if (stream._state === 'closing') {241      return Promise.reject(new TypeError('Cannot write to an already-closed stream'));242    }243    return WritableStreamDefaultWriterWrite(this, chunk);244  }245}246// Abstract operations for the WritableStreamDefaultWriter.247function IsWritableStreamDefaultWriter(x) {248  if (!typeIsObject(x)) {249    return false;250  }251  if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {252    return false;253  }254  return true;255}256// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.257function WritableStreamDefaultWriterAbort(writer, reason) {258  const stream = writer._ownerWritableStream;259  assert(stream !== undefined);260  return WritableStreamAbort(stream, reason);261}262function WritableStreamDefaultWriterClose(writer) {263  const stream = writer._ownerWritableStream;264  assert(stream !== undefined);265  const state = stream._state;266  if (state === 'closed' || state === 'errored') {267    return Promise.reject(new TypeError(268      `The stream (in ${state} state) is not in the writable state and cannot be closed`));269  }270  assert(state === 'writable');271  const promise = WritableStreamAddWriteRequest(stream);272  if (WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {273    defaultWriterReadyPromiseResolve(writer);274  }275  stream._state = 'closing';276  WritableStreamDefaultControllerClose(stream._writableStreamController);277  return promise;278}279function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {280  const stream = writer._ownerWritableStream;281  assert(stream !== undefined);282  const state = stream._state;283  if (state === 'closing' || state === 'closed') {284    return Promise.resolve();285  }286  if (state === 'errored') {287    return Promise.reject(stream._storedError);288  }289  assert(state === 'writable');290  return WritableStreamDefaultWriterClose(writer);291}292function WritableStreamDefaultWriterGetDesiredSize(writer) {293  const stream = writer._ownerWritableStream;294  const state = stream._state;295  if (state === 'errored') {296    return null;297  }298  if (state === 'closed') {299    return 0;300  }301  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);302}303function WritableStreamDefaultWriterRelease(writer) {304  const stream = writer._ownerWritableStream;305  assert(stream !== undefined);306  assert(stream._writer === writer);307  const releasedError = new TypeError(308    'Writer was released and can no longer be used to monitor the stream\'s closedness');309  const state = stream._state;310  if (state === 'writable' || state === 'closing') {311    defaultWriterClosedPromiseReject(writer, releasedError);312  } else {313    defaultWriterClosedPromiseResetToRejected(writer, releasedError);314  }315  writer._closedPromise.catch(() => {});316  if (state === 'writable' &&317      WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {318    defaultWriterReadyPromiseReject(writer, releasedError);319  } else {320    defaultWriterReadyPromiseResetToRejected(writer, releasedError);321  }322  writer._readyPromise.catch(() => {});323  stream._writer = undefined;324  writer._ownerWritableStream = undefined;325}326function WritableStreamDefaultWriterWrite(writer, chunk) {327  const stream = writer._ownerWritableStream;328  assert(stream !== undefined);329  const state = stream._state;330  if (state === 'closed' || state === 'errored') {331    return Promise.reject(new TypeError(332      `The stream (in ${state} state) is not in the writable state and cannot be written to`));333  }334  assert(state === 'writable');335  const promise = WritableStreamAddWriteRequest(stream);336  WritableStreamDefaultControllerWrite(stream._writableStreamController, chunk);337  return promise;338}339class WritableStreamDefaultController {340  constructor(stream, underlyingSink, size, highWaterMark) {341    if (IsWritableStream(stream) === false) {342      throw new TypeError('WritableStreamDefaultController can only be constructed with a WritableStream instance');343    }344    if (stream._writableStreamController !== undefined) {345      throw new TypeError(346        'WritableStreamDefaultController instances can only be created by the WritableStream constructor');347    }348    this._controlledWritableStream = stream;349    this._underlyingSink = underlyingSink;350    this._queue = [];351    this._started = false;352    this._writing = false;353    const normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);354    this._strategySize = normalizedStrategy.size;355    this._strategyHWM = normalizedStrategy.highWaterMark;356    const backpressure = WritableStreamDefaultControllerGetBackpressure(this);357    if (backpressure === true) {358      WritableStreamUpdateBackpressure(stream, backpressure);359    }360    const controller = this;361    const startResult = InvokeOrNoop(underlyingSink, 'start', [this]);362    Promise.resolve(startResult).then(363      () => {364        controller._started = true;365        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);366      },367      r => {368        WritableStreamDefaultControllerErrorIfNeeded(controller, r);369      }370    )371    .catch(rethrowAssertionErrorRejection);372  }373  error(e) {374    if (IsWritableStreamDefaultController(this) === false) {375      throw new TypeError(376        'WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');377    }378    const state = this._controlledWritableStream._state;379    if (state === 'closed' || state === 'errored') {380      throw new TypeError(`The stream is ${state} and so cannot be errored`);381    }382    WritableStreamDefaultControllerError(this, e);383  }384}385// Abstract operations implementing interface required by the WritableStream.386function WritableStreamDefaultControllerAbort(controller, reason) {387  controller._queue = [];388  const sinkAbortPromise = PromiseInvokeOrFallbackOrNoop(controller._underlyingSink, 'abort', [reason],389                                                         'close', [controller]);390  return sinkAbortPromise.then(() => undefined);391}392function WritableStreamDefaultControllerClose(controller) {393  EnqueueValueWithSize(controller._queue, 'close', 0);394  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);395}396function WritableStreamDefaultControllerGetDesiredSize(controller) {397  const queueSize = GetTotalQueueSize(controller._queue);398  return controller._strategyHWM - queueSize;399}400function WritableStreamDefaultControllerWrite(controller, chunk) {401  const stream = controller._controlledWritableStream;402  assert(stream._state === 'writable');403  let chunkSize = 1;404  if (controller._strategySize !== undefined) {405    try {406      chunkSize = controller._strategySize(chunk);407    } catch (chunkSizeE) {408      // TODO: Should we notify the sink of this error?409      WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);410      return;411    }412  }413  const writeRecord = { chunk };414  const lastBackpressure = WritableStreamDefaultControllerGetBackpressure(controller);415  try {416    EnqueueValueWithSize(controller._queue, writeRecord, chunkSize);417  } catch (enqueueE) {418    WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);419    return;420  }421  if (stream._state === 'writable') {422    const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);423    if (lastBackpressure !== backpressure) {424      WritableStreamUpdateBackpressure(stream, backpressure);425    }426  }427  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);428}429// Abstract operations for the WritableStreamDefaultController.430function IsWritableStreamDefaultController(x) {431  if (!typeIsObject(x)) {432    return false;433  }434  if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSink')) {435    return false;436  }437  return true;438}439function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {440  if (controller._controlledWritableStream._state === 'closed' ||441      controller._controlledWritableStream._state === 'errored') {442    return;443  }444  if (controller._started === false) {445    return;446  }447  if (controller._writing === true) {448    return;449  }450  if (controller._queue.length === 0) {451    return;452  }453  const writeRecord = PeekQueueValue(controller._queue);454  if (writeRecord === 'close') {455    WritableStreamDefaultControllerProcessClose(controller);456  } else {457    WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);458  }459}460function WritableStreamDefaultControllerErrorIfNeeded(controller, e) {461  if (controller._controlledWritableStream._state === 'writable' ||462      controller._controlledWritableStream._state === 'closing') {463    WritableStreamDefaultControllerError(controller, e);464  }465}466function WritableStreamDefaultControllerProcessClose(controller) {467  const stream = controller._controlledWritableStream;468  assert(stream._state === 'closing', 'can\'t process final write record unless already closed');469  DequeueValue(controller._queue);470  assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeued');471  const sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', [controller]);472  sinkClosePromise.then(473    () => {474      if (stream._state !== 'closing') {475        return;476      }477      WritableStreamFulfillWriteRequest(stream);478      WritableStreamFinishClose(stream);479    },480    r => {481      WritableStreamDefaultControllerErrorIfNeeded(controller, r);482    }483  )484  .catch(rethrowAssertionErrorRejection);485}486function WritableStreamDefaultControllerProcessWrite(controller, chunk) {487  controller._writing = true;488  const sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller]);489  sinkWritePromise.then(490    () => {491      const stream = controller._controlledWritableStream;492      const state = stream._state;493      if (state === 'errored' || state === 'closed') {494        return;495      }496      controller._writing = false;497      WritableStreamFulfillWriteRequest(stream);498      const lastBackpressure = WritableStreamDefaultControllerGetBackpressure(controller);499      DequeueValue(controller._queue);500      if (state !== 'closing') {501        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);502        if (lastBackpressure !== backpressure) {503          WritableStreamUpdateBackpressure(controller._controlledWritableStream, backpressure);504        }505      }506      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);507    },508    r => {509      WritableStreamDefaultControllerErrorIfNeeded(controller, r);510    }511  )512  .catch(rethrowAssertionErrorRejection);513}514function WritableStreamDefaultControllerGetBackpressure(controller) {515  const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);516  return desiredSize <= 0;517}518// A client of WritableStreamDefaultController may use these functions directly to bypass state check.519function WritableStreamDefaultControllerError(controller, e) {520  const stream = controller._controlledWritableStream;521  assert(stream._state === 'writable' || stream._state === 'closing');522  WritableStreamError(stream, e);523  controller._queue = [];524}525// Helper functions for the WritableStream.526function streamBrandCheckException(name) {527  return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);528}529// Helper functions for the WritableStreamDefaultWriter.530function defaultWriterBrandCheckException(name) {531  return new TypeError(532    `WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);533}534function defaultWriterLockException(name) {535  return new TypeError('Cannot ' + name + ' a stream using a released writer');536}537function defaultWriterClosedPromiseInitialize(writer) {538  writer._closedPromise = new Promise((resolve, reject) => {539    writer._closedPromise_resolve = resolve;540    writer._closedPromise_reject = reject;541  });542}543function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {544  writer._closedPromise = Promise.reject(reason);545  writer._closedPromise_resolve = undefined;546  writer._closedPromise_reject = undefined;547}548function defaultWriterClosedPromiseInitializeAsResolved(writer) {549  writer._closedPromise = Promise.resolve(undefined);550  writer._closedPromise_resolve = undefined;551  writer._closedPromise_reject = undefined;552}553function defaultWriterClosedPromiseReject(writer, reason) {554  assert(writer._closedPromise_resolve !== undefined);555  assert(writer._closedPromise_reject !== undefined);556  writer._closedPromise_reject(reason);557  writer._closedPromise_resolve = undefined;558  writer._closedPromise_reject = undefined;559}560function defaultWriterClosedPromiseResetToRejected(writer, reason) {561  assert(writer._closedPromise_resolve === undefined);562  assert(writer._closedPromise_reject === undefined);563  writer._closedPromise = Promise.reject(reason);564}565function defaultWriterClosedPromiseResolve(writer) {566  assert(writer._closedPromise_resolve !== undefined);567  assert(writer._closedPromise_reject !== undefined);568  writer._closedPromise_resolve(undefined);569  writer._closedPromise_resolve = undefined;570  writer._closedPromise_reject = undefined;571}572function defaultWriterReadyPromiseInitialize(writer) {573  writer._readyPromise = new Promise((resolve, reject) => {574    writer._readyPromise_resolve = resolve;575    writer._readyPromise_reject = reject;576  });577}578function defaultWriterReadyPromiseInitializeAsResolved(writer) {579  writer._readyPromise = Promise.resolve(undefined);580  writer._readyPromise_resolve = undefined;581  writer._readyPromise_reject = undefined;582}583function defaultWriterReadyPromiseReject(writer, reason) {584  assert(writer._readyPromise_resolve !== undefined);585  assert(writer._readyPromise_reject !== undefined);586  writer._readyPromise_reject(reason);587  writer._readyPromise_resolve = undefined;588  writer._readyPromise_reject = undefined;589}590function defaultWriterReadyPromiseReset(writer) {591  assert(writer._readyPromise_resolve === undefined);592  assert(writer._readyPromise_reject === undefined);593  writer._readyPromise = new Promise((resolve, reject) => {594    writer._readyPromise_resolve = resolve;595    writer._readyPromise_reject = reject;596  });597}...

Using AI Code Generation

1wpt.defaultWriterReadyPromiseReject();2wpt.defaultWriterReadyPromiseResolve();3wpt.defaultWriterReadyPromiseReject();4wpt.defaultWriterReadyPromiseReject();5wpt.defaultWriterReadyPromiseResolve();6wpt.defaultWriterReadyPromiseReject();7wpt.defaultWriterReadyPromiseReject();8wpt.defaultWriterReadyPromiseResolve();9wpt.defaultWriterReadyPromiseReject();10wpt.defaultWriterReadyPromiseReject();11wpt.defaultWriterReadyPromiseResolve();12wpt.defaultWriterReadyPromiseReject();13wpt.defaultWriterReadyPromiseReject();14wpt.defaultWriterReadyPromiseResolve();15wpt.defaultWriterReadyPromiseReject();16wpt.defaultWriterReadyPromiseReject();17wpt.defaultWriterReadyPromiseResolve();18wpt.defaultWriterReadyPromiseReject();19wpt.defaultWriterReadyPromiseReject();20wpt.defaultWriterReadyPromiseResolve();21wpt.defaultWriterReadyPromiseReject();

Using AI Code Generation

1defaultWriterReadyPromiseReject();2defaultWriterReadyPromiseResolve();3defaultWriterReadyPromiseReject();4defaultWriterReadyPromiseResolve();5defaultWriterReadyPromiseReject();6defaultWriterReadyPromiseResolve();7defaultWriterReadyPromiseReject();8defaultWriterReadyPromiseResolve();9defaultWriterReadyPromiseReject();10defaultWriterReadyPromiseResolve();11defaultWriterReadyPromiseReject();12defaultWriterReadyPromiseResolve();13defaultWriterReadyPromiseReject();14defaultWriterReadyPromiseResolve();15defaultWriterReadyPromiseReject();16defaultWriterReadyPromiseResolve();17defaultWriterReadyPromiseReject();18defaultWriterReadyPromiseResolve();19defaultWriterReadyPromiseReject();20defaultWriterReadyPromiseResolve();21defaultWriterReadyPromiseReject();22defaultWriterReadyPromiseResolve();23defaultWriterReadyPromiseReject();24defaultWriterReadyPromiseResolve();25defaultWriterReadyPromiseReject();

Using AI Code Generation

1importScripts("/resources/testharness.js");2importScripts("/resources/WebIDLParser.js");3importScripts("/resources/idlharness.js");4var idlArray = new IdlArray();5idlArray.add_idls('interface WritableStream { promise<void> abort(optional any reason); };');6idlArray.add_objects({7  WritableStream: ['new WritableStream()']8});9idlArray.test();10done();

Using AI Code Generation

1const wptools = require('wptools');2wptools.defaultWriterReadyPromiseReject('Error message');3const wptools = require('wptools');4wptools.defaultWriterReadyPromiseResolve();5const wptools = require('wptools');6wptools.defaultWriterReadyPromise();7const wptools = require('wptools');8wptools.getWriterReadyPromise();9const wptools = require('wptools');10wptools.getWriterReadyPromiseReject('Error message');11const wptools = require('wptools');12wptools.getWriterReadyPromiseResolve();13const wptools = require('wptools');14wptools.getWriterReadyPromise();15const wptools = require('wptools');16wptools.getWriterReadyPromiseReject('Error message');17const wptools = require('wptools');18wptools.getWriterReadyPromiseResolve();19const wptools = require('wptools');20wptools.getWriterReadyPromise();21const wptools = require('wptools');22wptools.getWriterReadyPromiseReject('Error message');23const wptools = require('wptools');24wptools.getWriterReadyPromiseResolve();25const wptools = require('wptools');

Using AI Code Generation

1var wpt = require('webpagetest');2wpt = new wpt('API_KEY');3wpt.defaultWriterReadyPromiseReject();4var wpt = require('webpagetest');5wpt = new wpt('API_KEY');6wpt.defaultWriterReadyPromiseResolve();7var wpt = require('webpagetest');8wpt = new wpt('API_KEY');9wpt.deleteTest('testId', function(err, data) {10    if(err) {11        console.log(err);12    } else {13        console.log(data);14    }15});16var wpt = require('webpagetest');17wpt = new wpt('API_KEY');18wpt.getLocations(function(err, data) {19    if(err) {20        console.log(err);21    } else {22        console.log(data);23    }24});25var wpt = require('webpagetest');26wpt = new wpt('API_KEY');27wpt.getLocations(function(err, data) {28    if(err) {29        console.log(err);30    } else {31        console.log(data);32    }33});34var wpt = require('webpagetest');35wpt = new wpt('API_KEY');36wpt.getLocations(function(err, data) {37    if(err) {38        console.log(err);39    } else {40        console.log(data);41    }42});43var wpt = require('webpagetest');44wpt = new wpt('API_KEY');45wpt.getLocations(function(err, data) {46    if(err) {47        console.log(err);48    } else {49        console.log(data);50    }51});52var wpt = require('webpagetest');53wpt = new wpt('API_KEY');54wpt.getLocations(function(err, data) {55    if(err) {56        console.log(err);57    } else {58        console.log(data);59    }60});

Using AI Code Generation

1var wpt = new WorkerPerformanceTimeline();2var promise = wpt.defaultWriterReadyPromiseReject();3promise.then(function (value) {4}, function (error) {5});6var wpt = new WorkerPerformanceTimeline();7var promise = wpt.defaultWriterReadyPromiseResolve();8promise.then(function (value) {9}, function (error) {10});11var wpt = new WorkerPerformanceTimeline();12var promise = wpt.defaultWriterReadyPromiseResolveWith();13promise.then(function (value) {14}, function (error) {15});16var wpt = new WorkerPerformanceTimeline();17var promise = wpt.defaultWriterReadyPromiseWithFulfillmentHandler();18promise.then(function (value) {19}, function (error) {20});21var wpt = new WorkerPerformanceTimeline();22var promise = wpt.defaultWriterReadyPromiseWithRejectionHandler();23promise.then(function (value) {24}, function (error) {25});26var wpt = new WorkerPerformanceTimeline();27var promise = wpt.defaultWriterReadyPromiseWithSettledHandler();28promise.then(function (value) {29}, function (error) {30});31var wpt = new WorkerPerformanceTimeline();32var entries = wpt.getEntries();33for (var i = 0; i < entries.length; i++) {34    console.log(entries[i]);35}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.