@highstate/designer 0.7.1 → 0.7.3

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

@@ -1,239 +0,0 @@
-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

@@ -1,23 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,83 +0,0 @@
-/** @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

@@ -1,26 +0,0 @@
-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 };