1 files changed, 136 insertions, 0 deletions
diff --git a/cli/js/streams/writable-stream-default-writer.ts b/cli/js/streams/writable-stream-default-writer.ts
new file mode 100644
index 000000000..f38aa26bb
--- /dev/null
+++ b/cli/js/streams/writable-stream-default-writer.ts
@@ -0,0 +1,136 @@
+// TODO reenable this code when we enable writableStreams and transport types
+// // Forked from https://github.com/stardazed/sd-streams/tree/8928cf04b035fd02fb1340b7eb541c76be37e546
+// // Copyright (c) 2018-Present by Arthur Langereis - @zenmumbler MIT
+
+// /**
+//  * streams/writable-stream-default-writer - WritableStreamDefaultWriter class implementation
+//  * Part of Stardazed
+//  * (c) 2018-Present by Arthur Langereis - @zenmumbler
+//  * https://github.com/stardazed/sd-streams
+//  */
+
+// import * as ws from "./writable-internals.ts";
+// import * as shared from "./shared-internals.ts";
+
+// export class WritableStreamDefaultWriter<InputType>
+//   implements ws.WritableStreamDefaultWriter<InputType> {
+//   [ws.ownerWritableStream_]: ws.WritableStream<InputType> | undefined;
+//   [ws.readyPromise_]: shared.ControlledPromise<void>;
+//   [ws.closedPromise_]: shared.ControlledPromise<void>;
+
+//   constructor(stream: ws.WritableStream<InputType>) {
+//     if (!ws.isWritableStream(stream)) {
+//       throw new TypeError();
+//     }
+//     if (ws.isWritableStreamLocked(stream)) {
+//       throw new TypeError("Stream is already locked");
+//     }
+//     this[ws.ownerWritableStream_] = stream;
+//     stream[ws.writer_] = this;
+
+//     const readyPromise = shared.createControlledPromise<void>();
+//     const closedPromise = shared.createControlledPromise<void>();
+//     this[ws.readyPromise_] = readyPromise;
+//     this[ws.closedPromise_] = closedPromise;
+
+//     const state = stream[shared.state_];
+//     if (state === "writable") {
+//       if (
+//         !ws.writableStreamCloseQueuedOrInFlight(stream) &&
+//         stream[ws.backpressure_]
+//       ) {
+//         // OK Set this.[[readyPromise]] to a new promise.
+//       } else {
+//         readyPromise.resolve(undefined);
+//       }
+//       // OK Set this.[[closedPromise]] to a new promise.
+//     } else if (state === "erroring") {
+//       readyPromise.reject(stream[shared.storedError_]);
+//       readyPromise.promise.catch(() => {});
+//       // OK Set this.[[closedPromise]] to a new promise.
+//     } else if (state === "closed") {
+//       readyPromise.resolve(undefined);
+//       closedPromise.resolve(undefined);
+//     } else {
+//       // Assert: state is "errored".
+//       const storedError = stream[shared.storedError_];
+//       readyPromise.reject(storedError);
+//       readyPromise.promise.catch(() => {});
+//       closedPromise.reject(storedError);
+//       closedPromise.promise.catch(() => {});
+//     }
+//   }
+
+//   abort(reason: shared.ErrorResult): Promise<void> {
+//     if (!ws.isWritableStreamDefaultWriter(this)) {
+//       return Promise.reject(new TypeError());
+//     }
+//     if (this[ws.ownerWritableStream_] === undefined) {
+//       return Promise.reject(
+//         new TypeError("Writer is not connected to a stream")
+//       );
+//     }
+//     return ws.writableStreamDefaultWriterAbort(this, reason);
+//   }
+
+//   close(): Promise<void> {
+//     if (!ws.isWritableStreamDefaultWriter(this)) {
+//       return Promise.reject(new TypeError());
+//     }
+//     const stream = this[ws.ownerWritableStream_];
+//     if (stream === undefined) {
+//       return Promise.reject(
+//         new TypeError("Writer is not connected to a stream")
+//       );
+//     }
+//     if (ws.writableStreamCloseQueuedOrInFlight(stream)) {
+//       return Promise.reject(new TypeError());
+//     }
+//     return ws.writableStreamDefaultWriterClose(this);
+//   }
+
+//   releaseLock(): void {
+//     const stream = this[ws.ownerWritableStream_];
+//     if (stream === undefined) {
+//       return;
+//     }
+//     // Assert: stream.[[writer]] is not undefined.
+//     ws.writableStreamDefaultWriterRelease(this);
+//   }
+
+//   write(chunk: InputType): Promise<void> {
+//     if (!ws.isWritableStreamDefaultWriter(this)) {
+//       return Promise.reject(new TypeError());
+//     }
+//     if (this[ws.ownerWritableStream_] === undefined) {
+//       return Promise.reject(
+//         new TypeError("Writer is not connected to a stream")
+//       );
+//     }
+//     return ws.writableStreamDefaultWriterWrite(this, chunk);
+//   }
+
+//   get closed(): Promise<void> {
+//     if (!ws.isWritableStreamDefaultWriter(this)) {
+//       return Promise.reject(new TypeError());
+//     }
+//     return this[ws.closedPromise_].promise;
+//   }
+
+//   get desiredSize(): number | null {
+//     if (!ws.isWritableStreamDefaultWriter(this)) {
+//       throw new TypeError();
+//     }
+//     if (this[ws.ownerWritableStream_] === undefined) {
+//       throw new TypeError("Writer is not connected to stream");
+//     }
+//     return ws.writableStreamDefaultWriterGetDesiredSize(this);
+//   }
+
+//   get ready(): Promise<void> {
+//     if (!ws.isWritableStreamDefaultWriter(this)) {
+//       return Promise.reject(new TypeError());
+//     }
+//     return this[ws.readyPromise_].promise;
+//   }
+// }