@highstate/designer 0.3.2 → 0.3.3

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/sse.mjs

@@ -0,0 +1,355 @@
+import { Unpromise } from '../../vendor/unpromise/unpromise.mjs';
+import { getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
+import { isAbortError } from '../http/isAbortError.mjs';
+import { run, identity } from '../utils.mjs';
+import { isTrackedEnvelope } from './tracked.mjs';
+import { takeWithGrace, withMaxDuration } from './utils/asyncIterable.mjs';
+import { makeAsyncResource } from './utils/disposable.mjs';
+import { readableStreamFrom } from './utils/readableStreamFrom.mjs';
+import { timerResource, disposablePromiseTimerResult } from './utils/timerResource.mjs';
+import { withPing, PING_SYM } from './utils/withPing.mjs';
+
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+const PING_EVENT = 'ping';
+const SERIALIZED_ERROR_EVENT = 'serialized-error';
+const CONNECTED_EVENT = 'connected';
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */ function sseStreamProducer(opts) {
+    const { serialize = identity } = opts;
+    const ping = {
+        enabled: opts.ping?.enabled ?? false,
+        intervalMs: opts.ping?.intervalMs ?? 1000
+    };
+    const client = opts.client ?? {};
+    if (ping.enabled && client.reconnectAfterInactivityMs && ping.intervalMs > client.reconnectAfterInactivityMs) {
+        throw new Error(`Ping interval must be less than client reconnect interval to prevent unnecessary reconnection - ping.intervalMs: ${ping.intervalMs} client.reconnectAfterInactivityMs: ${client.reconnectAfterInactivityMs}`);
+    }
+    async function* generator() {
+        yield {
+            event: CONNECTED_EVENT,
+            data: JSON.stringify(client)
+        };
+        let iterable = opts.data;
+        if (opts.emitAndEndImmediately) {
+            iterable = takeWithGrace(iterable, {
+                count: 1,
+                gracePeriodMs: 1
+            });
+        }
+        if (opts.maxDurationMs && opts.maxDurationMs > 0 && opts.maxDurationMs !== Infinity) {
+            iterable = withMaxDuration(iterable, {
+                maxDurationMs: opts.maxDurationMs
+            });
+        }
+        if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {
+            iterable = withPing(iterable, ping.intervalMs);
+        }
+        // We need those declarations outside the loop for garbage collection reasons. If they were
+        // declared inside, they would not be freed until the next value is present.
+        let value;
+        let chunk;
+        for await (value of iterable){
+            if (value === PING_SYM) {
+                yield {
+                    event: PING_EVENT,
+                    data: ''
+                };
+                continue;
+            }
+            chunk = isTrackedEnvelope(value) ? {
+                id: value[0],
+                data: value[1]
+            } : {
+                data: value
+            };
+            chunk.data = JSON.stringify(serialize(chunk.data));
+            yield chunk;
+            // free up references for garbage collection
+            value = null;
+            chunk = null;
+        }
+    }
+    async function* generatorWithErrorHandling() {
+        try {
+            yield* generator();
+        } catch (cause) {
+            if (isAbortError(cause)) {
+                // ignore abort errors, send any other errors
+                return;
+            }
+            // `err` must be caused by `opts.data`, `JSON.stringify` or `serialize`.
+            // So, a user error in any case.
+            const error = getTRPCErrorFromUnknown(cause);
+            const data = opts.formatError?.({
+                error
+            }) ?? null;
+            yield {
+                event: SERIALIZED_ERROR_EVENT,
+                data: JSON.stringify(serialize(data))
+            };
+        }
+    }
+    const stream = readableStreamFrom(generatorWithErrorHandling());
+    return stream.pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            if ('event' in chunk) {
+                controller.enqueue(`event: ${chunk.event}\n`);
+            }
+            if ('data' in chunk) {
+                controller.enqueue(`data: ${chunk.data}\n`);
+            }
+            if ('id' in chunk) {
+                controller.enqueue(`id: ${chunk.id}\n`);
+            }
+            if ('comment' in chunk) {
+                controller.enqueue(`: ${chunk.comment}\n`);
+            }
+            controller.enqueue('\n\n');
+        }
+    }));
+}
+async function withTimeout(opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const timeoutPromise = _ts_add_disposable_resource(env, timerResource(opts.timeoutMs), false);
+        ;
+        const res = await Unpromise.race([
+            opts.promise,
+            timeoutPromise.start()
+        ]);
+        if (res === disposablePromiseTimerResult) {
+            return await opts.onTimeout();
+        }
+        return res;
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        _ts_dispose_resources(env);
+    }
+}
+/**
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */ function sseStreamConsumer(opts) {
+    const { deserialize = (v)=>v } = opts;
+    let clientOptions = {};
+    const signal = opts.signal;
+    let _es = null;
+    const createStream = ()=>new ReadableStream({
+            async start (controller) {
+                const [url, init] = await Promise.all([
+                    opts.url(),
+                    opts.init()
+                ]);
+                const eventSource = _es = new opts.EventSource(url, init);
+                controller.enqueue({
+                    type: 'connecting',
+                    eventSource: _es,
+                    event: null
+                });
+                eventSource.addEventListener(CONNECTED_EVENT, (_msg)=>{
+                    const msg = _msg;
+                    const options = JSON.parse(msg.data);
+                    clientOptions = options;
+                    controller.enqueue({
+                        type: 'connected',
+                        options,
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener(SERIALIZED_ERROR_EVENT, (_msg)=>{
+                    const msg = _msg;
+                    controller.enqueue({
+                        type: 'serialized-error',
+                        error: deserialize(JSON.parse(msg.data)),
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener(PING_EVENT, ()=>{
+                    controller.enqueue({
+                        type: 'ping',
+                        eventSource
+                    });
+                });
+                eventSource.addEventListener('error', (event)=>{
+                    if (eventSource.readyState === EventSource.CLOSED) {
+                        controller.error(event);
+                    } else {
+                        controller.enqueue({
+                            type: 'connecting',
+                            eventSource,
+                            event
+                        });
+                    }
+                });
+                eventSource.addEventListener('message', (_msg)=>{
+                    const msg = _msg;
+                    const chunk = deserialize(JSON.parse(msg.data));
+                    const def = {
+                        data: chunk
+                    };
+                    if (msg.lastEventId) {
+                        def.id = msg.lastEventId;
+                    }
+                    controller.enqueue({
+                        type: 'data',
+                        data: def,
+                        eventSource
+                    });
+                });
+                const onAbort = ()=>{
+                    controller.close();
+                    eventSource.close();
+                };
+                if (signal.aborted) {
+                    onAbort();
+                } else {
+                    signal.addEventListener('abort', onAbort);
+                }
+            },
+            cancel () {
+                _es?.close();
+            }
+        });
+    const getStreamResource = ()=>{
+        let stream = createStream();
+        let reader = stream.getReader();
+        async function dispose() {
+            await reader.cancel();
+            _es = null;
+        }
+        return makeAsyncResource({
+            read () {
+                return reader.read();
+            },
+            async recreate () {
+                await dispose();
+                stream = createStream();
+                reader = stream.getReader();
+            }
+        }, dispose);
+    };
+    return run(async function*() {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            const stream = _ts_add_disposable_resource(env, getStreamResource(), true);
+            ;
+            while(true){
+                let promise = stream.read();
+                const timeoutMs = clientOptions.reconnectAfterInactivityMs;
+                if (timeoutMs) {
+                    promise = withTimeout({
+                        promise,
+                        timeoutMs,
+                        onTimeout: async ()=>{
+                            const res = {
+                                value: {
+                                    type: 'timeout',
+                                    ms: timeoutMs,
+                                    eventSource: _es
+                                },
+                                done: false
+                            };
+                            // Close and release old reader
+                            await stream.recreate();
+                            return res;
+                        }
+                    });
+                }
+                const result = await promise;
+                if (result.done) {
+                    return result.value;
+                }
+                yield result.value;
+            }
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
+    });
+}
+const sseHeaders = {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'X-Accel-Buffering': 'no',
+    Connection: 'keep-alive'
+};
+
+export { sseHeaders, sseStreamConsumer, sseStreamProducer };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/tracked.mjs

@@ -0,0 +1,25 @@
+const trackedSymbol = Symbol();
+/**
+ * Produce a typed server-sent event message
+ * @deprecated use `tracked(id, data)` instead
+ */ function sse(event) {
+    return tracked(event.id, event.data);
+}
+function isTrackedEnvelope(value) {
+    return Array.isArray(value) && value[2] === trackedSymbol;
+}
+/**
+ * Automatically track an event so that it can be resumed from a given id if the connection is lost
+ */ function tracked(id, data) {
+    if (id === '') {
+        // This limitation could be removed by using different SSE event names / channels for tracked event and non-tracked event
+        throw new Error('`id` must not be an empty string as empty string is the same as not setting the id at all');
+    }
+    return [
+        id,
+        data,
+        trackedSymbol
+    ];
+}
+
+export { isTrackedEnvelope, sse, tracked };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/utils/asyncIterable.mjs

@@ -0,0 +1,167 @@
+import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
+import { makeAsyncResource } from './disposable.mjs';
+import { timerResource, disposablePromiseTimerResult } from './timerResource.mjs';
+
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+function iteratorResource(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return makeAsyncResource(iterator, async ()=>{
+        await iterator.return?.();
+    });
+}
+/**
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */ async function* withMaxDuration(iterable, opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        const timer = _ts_add_disposable_resource(env, timerResource(opts.maxDurationMs), false);
+        ;
+        const timerPromise = timer.start();
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        while(true){
+            result = await Unpromise.race([
+                iterator.next(),
+                timerPromise
+            ]);
+            if (result === disposablePromiseTimerResult) {
+                // cancelled due to timeout
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result;
+            }
+            yield result.value;
+            // free up reference for garbage collection
+            result = null;
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
+ * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
+ * values may still come through. After this period, the generator stops.
+ */ async function* takeWithGrace(iterable, opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        const timer = _ts_add_disposable_resource(env, timerResource(opts.gracePeriodMs), false);
+        ;
+        let count = opts.count;
+        let timerPromise = new Promise(()=>{
+        // never resolves
+        });
+        while(true){
+            result = await Unpromise.race([
+                iterator.next(),
+                timerPromise
+            ]);
+            if (result === disposablePromiseTimerResult) {
+                // cancelled
+                const res = await iterator.return?.();
+                return res?.value;
+            }
+            if (result.done) {
+                return result.value;
+            }
+            yield result.value;
+            if (--count === 0) {
+                timerPromise = timer.start();
+            }
+            // free up reference for garbage collection
+            result = null;
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+
+export { iteratorResource, takeWithGrace, withMaxDuration };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/utils/createDeferred.mjs

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+
+export { createDeferred };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/utils/disposable.mjs

@@ -0,0 +1,41 @@
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+var _Symbol, // @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+_Symbol1;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */ function makeResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.dispose]) {
+        throw new Error('Symbol.dispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.dispose] = dispose;
+    return it;
+}
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */ function makeAsyncResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.asyncDispose]) {
+        throw new Error('Symbol.asyncDispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.asyncDispose] = dispose;
+    return it;
+}
+
+export { makeAsyncResource, makeResource };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/utils/readableStreamFrom.mjs

@@ -0,0 +1,23 @@
+/**
+ * Creates a ReadableStream from an AsyncIterable.
+ *
+ * @param iterable - The source AsyncIterable to stream from
+ * @returns A ReadableStream that yields values from the AsyncIterable
+ */ function readableStreamFrom(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async cancel () {
+            await iterator.return?.();
+        },
+        async pull (controller) {
+            const result = await iterator.next();
+            if (result.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(result.value);
+        }
+    });
+}
+
+export { readableStreamFrom };

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/stream/utils/timerResource.mjs

@@ -0,0 +1,23 @@
+import { makeResource } from './disposable.mjs';
+
+const disposablePromiseTimerResult = Symbol();
+function timerResource(ms) {
+    let timer = null;
+    return makeResource({
+        start () {
+            if (timer) {
+                throw new Error('Timer already started');
+            }
+            const promise = new Promise((resolve)=>{
+                timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
+            });
+            return promise;
+        }
+    }, ()=>{
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
+}
+
+export { disposablePromiseTimerResult, timerResource };