Diffusion Ant (mir/inline-method) Code

ant/tests/react_like_async_iterable_controller.js
3fa05edd2fe3mir/inline-method

react_like_async_iterable_controller.js
View Options

			class ReactPromise {
			constructor(status, value, reason) {
			this.status = status;
			this.value = value;
			this.reason = reason;
			}
			}

			function createPendingChunk() {
			return new ReactPromise("pending", null, null);
			}

			function createResolvedIteratorResultChunk(response, value, done) {
			return new ReactPromise(
			"resolved_model",
			(done ? "{\"done\":true,\"value\":" : "{\"done\":false,\"value\":") + value + "}",
			response
			);
			}

			function resolveModelChunk(response, chunk, value) {
			if ("pending" !== chunk.status) {
			chunk.reason.enqueueModel(value);
			return;
			}

			chunk.status = "resolved_model";
			chunk.value = value;
			chunk.reason = response;
			}

			function resolveIteratorResultChunk(response, chunk, value, done) {
			resolveModelChunk(
			response,
			chunk,
			(done ? "{\"done\":true,\"value\":" : "{\"done\":false,\"value\":") + value + "}"
			);
			}

			function startAsyncIterable(response, id, iterator) {
			const buffer = [];
			let closed = false;
			let nextWriteIndex = 0;
			const iterable = {};

			iterable[Symbol.asyncIterator] = function () {
			let nextReadIndex = 0;
			return {
			next(arg) {
			if (arg !== undefined) throw new Error("bad arg");
			if (nextReadIndex === buffer.length) {
			if (closed) {
			return new ReactPromise("fulfilled", { done: true, value: undefined }, null);
			}
			buffer[nextReadIndex] = createPendingChunk(response);
			}
			return buffer[nextReadIndex++];
			}
			};
			};

			const controller = {
			enqueueValue(value) {
			if (nextWriteIndex === buffer.length) {
			buffer[nextWriteIndex] = new ReactPromise("fulfilled", { done: false, value }, null);
			} else {
			const chunk = buffer[nextWriteIndex];
			chunk.status = "fulfilled";
			chunk.value = { done: false, value };
			chunk.reason = null;
			}
			nextWriteIndex++;
			},
			enqueueModel(value) {
			if (nextWriteIndex === buffer.length) {
			buffer[nextWriteIndex] = createResolvedIteratorResultChunk(response, value, false);
			} else {
			resolveIteratorResultChunk(response, buffer[nextWriteIndex], value, false);
			}
			nextWriteIndex++;
			},
			close(value) {
			if (!closed) {
			closed = true;
			if (nextWriteIndex === buffer.length) {
			buffer[nextWriteIndex] = createResolvedIteratorResultChunk(response, value, true);
			} else {
			resolveIteratorResultChunk(response, buffer[nextWriteIndex], value, true);
			}
			nextWriteIndex++;
			}
			},
			error(error) {
			throw error;
			}
			};

			response._chunks.set(id, new ReactPromise("fulfilled", iterator ? iterable[Symbol.asyncIterator]() : iterable, controller));
			return { buffer, controller };
			}

			function log(label, fn) {
			try {
			const out = fn();
			console.log(`${label}:${out}`);
			} catch (error) {
			console.log(`${label}:ERR:${error && error.message ? error.message : String(error)}`);
			}
			}

			const response = { _chunks: new Map() };
			const id = 1;

			startAsyncIterable(response, id, true);
			const chunk = response._chunks.get(id);

			log("reasonType", () => typeof chunk.reason);
			log("enqueueModelType", () => typeof chunk.reason.enqueueModel);

			resolveModelChunk(response, chunk, "\"1\"");
			console.log(`bufferLength:${chunk.reason ? "controller" : "missing"}`);

			const response2 = { _chunks: new Map() };
			const id2 = 2;
			response2._chunks.set(id2, new ReactPromise("resolved_model", "\"boot\"", response2));
			const badChunk = response2._chunks.get(id2);
			log("badReasonType", () => typeof badChunk.reason);
			log("badEnqueueModelType", () => typeof badChunk.reason.enqueueModel);
			log("badResolve", () => {
			resolveModelChunk(response2, badChunk, "\"next\"");
			return "ok";
			});

Owner Packages

No Owners