@highstate/designer 0.9.5 → 0.9.6

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

@@ -0,0 +1,239 @@
+import { createDeferred } from './createDeferred.mjs';
+import { makeAsyncResource } from './disposable.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 (!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];
+            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 {
+        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 createManagedIterator(iterable, onResult) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    let state = 'idle';
+    function cleanup() {
+        state = 'done';
+        onResult = ()=>{
+        // noop
+        };
+    }
+    function pull() {
+        if (state !== 'idle') {
+            return;
+        }
+        state = 'pending';
+        const next = iterator.next();
+        next.then((result)=>{
+            if (result.done) {
+                state = 'done';
+                onResult({
+                    status: 'return',
+                    value: result.value
+                });
+                cleanup();
+                return;
+            }
+            state = 'idle';
+            onResult({
+                status: 'yield',
+                value: result.value
+            });
+        }).catch((cause)=>{
+            onResult({
+                status: 'error',
+                error: cause
+            });
+            cleanup();
+        });
+    }
+    return {
+        pull,
+        destroy: async ()=>{
+            cleanup();
+            await iterator.return?.();
+        }
+    };
+}
+/**
+ * Creates a new async iterable that merges multiple async iterables into a single stream.
+ * Values from the input iterables are yielded in the order they resolve, similar to Promise.race().
+ *
+ * New iterables can be added dynamically using the returned {@link MergedAsyncIterables.add} method, even after iteration has started.
+ *
+ * If any of the input iterables throws an error, that error will be propagated through the merged stream.
+ * Other iterables will not continue to be processed.
+ *
+ * @template TYield The type of values yielded by the input iterables
+ */ function mergeAsyncIterables() {
+    let state = 'idle';
+    let flushSignal = createDeferred();
+    /**
+   * used while {@link state} is `idle`
+   */ const iterables = [];
+    /**
+   * used while {@link state} is `pending`
+   */ const iterators = new Set();
+    const buffer = [];
+    function initIterable(iterable) {
+        if (state !== 'pending') {
+            // shouldn't happen
+            return;
+        }
+        const iterator = createManagedIterator(iterable, (result)=>{
+            if (state !== 'pending') {
+                // shouldn't happen
+                return;
+            }
+            switch(result.status){
+                case 'yield':
+                    buffer.push([
+                        iterator,
+                        result
+                    ]);
+                    break;
+                case 'return':
+                    iterators.delete(iterator);
+                    break;
+                case 'error':
+                    buffer.push([
+                        iterator,
+                        result
+                    ]);
+                    iterators.delete(iterator);
+                    break;
+            }
+            flushSignal.resolve();
+        });
+        iterators.add(iterator);
+        iterator.pull();
+    }
+    return {
+        add (iterable) {
+            switch(state){
+                case 'idle':
+                    iterables.push(iterable);
+                    break;
+                case 'pending':
+                    initIterable(iterable);
+                    break;
+            }
+        },
+        async *[Symbol.asyncIterator] () {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                if (state !== 'idle') {
+                    throw new Error('Cannot iterate twice');
+                }
+                state = 'pending';
+                const _finally = _ts_add_disposable_resource(env, makeAsyncResource({}, async ()=>{
+                    state = 'done';
+                    const errors = [];
+                    await Promise.all(Array.from(iterators.values()).map(async (it)=>{
+                        try {
+                            await it.destroy();
+                        } catch (cause) {
+                            errors.push(cause);
+                        }
+                    }));
+                    buffer.length = 0;
+                    iterators.clear();
+                    flushSignal.resolve();
+                    if (errors.length > 0) {
+                        throw new AggregateError(errors);
+                    }
+                }), true);
+                ;
+                while(iterables.length > 0){
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    initIterable(iterables.shift());
+                }
+                while(iterators.size > 0){
+                    await flushSignal.promise;
+                    while(buffer.length > 0){
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        const [iterator, result] = buffer.shift();
+                        switch(result.status){
+                            case 'yield':
+                                yield result.value;
+                                iterator.pull();
+                                break;
+                            case 'error':
+                                throw result.error;
+                        }
+                    }
+                    flushSignal = createDeferred();
+                }
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        }
+    };
+}
+
+export { mergeAsyncIterables };

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 };

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

@@ -0,0 +1,127 @@
+import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
+import { iteratorResource } from './asyncIterable.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);
+}
+const PING_SYM = Symbol('ping');
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
+ * whenever no value has been yielded for {@link pingIntervalMs}.
+ */ async function* withPing(iterable, pingIntervalMs) {
+    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;
+        let nextPromise = iterator.next();
+        while(true){
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const pingPromise = _ts_add_disposable_resource(env, timerResource(pingIntervalMs), false);
+                ;
+                result = await Unpromise.race([
+                    nextPromise,
+                    pingPromise.start()
+                ]);
+                if (result === disposablePromiseTimerResult) {
+                    // cancelled
+                    yield PING_SYM;
+                    continue;
+                }
+                if (result.done) {
+                    return result.value;
+                }
+                nextPromise = iterator.next();
+                yield result.value;
+                // free up reference for garbage collection
+                result = null;
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                _ts_dispose_resources(env);
+            }
+        }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+}
+
+export { PING_SYM, withPing };

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

@@ -0,0 +1,101 @@
+import { isObject } from './utils.mjs';
+
+/**
+ * @internal
+ */ function getDataTransformer(transformer) {
+    if ('input' in transformer) {
+        return transformer;
+    }
+    return {
+        input: transformer,
+        output: transformer
+    };
+}
+/**
+ * @internal
+ */ const defaultTransformer = {
+    input: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    },
+    output: {
+        serialize: (obj)=>obj,
+        deserialize: (obj)=>obj
+    }
+};
+function transformTRPCResponseItem(config, item) {
+    if ('error' in item) {
+        return {
+            ...item,
+            error: config.transformer.output.serialize(item.error)
+        };
+    }
+    if ('data' in item.result) {
+        return {
+            ...item,
+            result: {
+                ...item.result,
+                data: config.transformer.output.serialize(item.result.data)
+            }
+        };
+    }
+    return item;
+}
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/ function transformTRPCResponse(config, itemOrItems) {
+    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
+}
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */ function transformResultInner(response, transformer) {
+    if ('error' in response) {
+        const error = transformer.deserialize(response.error);
+        return {
+            ok: false,
+            error: {
+                ...response,
+                error
+            }
+        };
+    }
+    const result = {
+        ...response.result,
+        ...(!response.result.type || response.result.type === 'data') && {
+            type: 'data',
+            data: transformer.deserialize(response.result.data)
+        }
+    };
+    return {
+        ok: true,
+        result
+    };
+}
+class TransformResultError extends Error {
+    constructor(){
+        super('Unable to transform response from server');
+    }
+}
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */ function transformResult(response, transformer) {
+    let result;
+    try {
+        // Use the data transformers on the JSON-response
+        result = transformResultInner(response, transformer);
+    } catch  {
+        throw new TransformResultError();
+    }
+    // check that output of the transformers is a valid TRPCResponse
+    if (!result.ok && (!isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
+        throw new TransformResultError();
+    }
+    if (result.ok && !isObject(result.result)) {
+        throw new TransformResultError();
+    }
+    return result;
+}
+
+export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse };

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

@@ -0,0 +1,83 @@
+/** @internal */ const unsetMarker = Symbol();
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */ function mergeWithoutOverrides(obj1, ...objs) {
+    const newObj = Object.assign(Object.create(null), obj1);
+    for (const overrides of objs){
+        for(const key in overrides){
+            if (key in newObj && newObj[key] !== overrides[key]) {
+                throw new Error(`Duplicate key ${key}`);
+            }
+            newObj[key] = overrides[key];
+        }
+    }
+    return newObj;
+}
+/**
+ * Check that value is object
+ * @internal
+ */ function isObject(value) {
+    return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+function isFunction(fn) {
+    return typeof fn === 'function';
+}
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */ function omitPrototype(obj) {
+    return Object.assign(Object.create(null), obj);
+}
+const asyncIteratorsSupported = typeof Symbol === 'function' && !!Symbol.asyncIterator;
+function isAsyncIterable(value) {
+    return asyncIteratorsSupported && isObject(value) && Symbol.asyncIterator in value;
+}
+/**
+ * Run an IIFE
+ */ const run = (fn)=>fn();
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() {}
+function identity(it) {
+    return it;
+}
+/**
+ * Generic runtime assertion function. Throws, if the condition is not `true`.
+ *
+ * Can be used as a slightly less dangerous variant of type assertions. Code
+ * mistakes would be revealed at runtime then (hopefully during testing).
+ */ function assert(condition, msg = 'no additional info') {
+    if (!condition) {
+        throw new Error(`AssertionError: ${msg}`);
+    }
+}
+function sleep(ms = 0) {
+    return new Promise((res)=>setTimeout(res, ms));
+}
+/**
+ * Ponyfill for
+ * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
+ */ function abortSignalsAnyPonyfill(signals) {
+    if (typeof AbortSignal.any === 'function') {
+        return AbortSignal.any(signals);
+    }
+    const ac = new AbortController();
+    for (const signal of signals){
+        if (signal.aborted) {
+            trigger();
+            break;
+        }
+        signal.addEventListener('abort', trigger, {
+            once: true
+        });
+    }
+    return ac.signal;
+    function trigger() {
+        ac.abort();
+        for (const signal of signals){
+            signal.removeEventListener('abort', trigger);
+        }
+    }
+}
+
+export { abortSignalsAnyPonyfill, assert, identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, sleep, unsetMarker };

package/.output/server/node_modules/@trpc/server/dist/vendor/standard-schema-v1/error.mjs

@@ -0,0 +1,26 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/** A schema error with useful information. */ class StandardSchemaV1Error extends Error {
+    /**
+   * Creates a schema error with useful information.
+   *
+   * @param issues The schema issues.
+   */ constructor(issues){
+        super(issues[0]?.message), /** The schema issues. */ _define_property(this, "issues", void 0);
+        this.name = 'SchemaError';
+        this.issues = issues;
+    }
+}
+
+export { StandardSchemaV1Error };