@highstate/designer 0.4.1 → 0.4.2

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/unpromise/unpromise.mjs

@@ -1,289 +0,0 @@
-/* eslint-disable @typescript-eslint/unbound-method */ 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;
-}
-var _computedKey;
-/** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
- * which is retained for the lifetime of the original Promise.
- */ const subscribableCache = new WeakMap();
-/** A NOOP function allowing a consistent interface for settled
- * SubscribedPromises (settled promises are not subscribed - they resolve
- * immediately). */ const NOOP = ()=>{
-// noop
-};
-_computedKey = Symbol.toStringTag;
-let _computedKey1 = _computedKey;
-/**
- * Every `Promise<T>` can be shadowed by a single `ProxyPromise<T>`. It is
- * created once, cached and reused throughout the lifetime of the Promise. Get a
- * Promise's ProxyPromise using `Unpromise.proxy(promise)`.
- *
- * The `ProxyPromise<T>` attaches handlers to the original `Promise<T>`
- * `.then()` and `.catch()` just once. Promises derived from it use a
- * subscription- (and unsubscription-) based mechanism that monitors these
- * handlers.
- *
- * Every time you call `.subscribe()`, `.then()` `.catch()` or `.finally()` on a
- * `ProxyPromise<T>` it returns a `SubscribedPromise<T>` having an additional
- * `unsubscribe()` method. Calling `unsubscribe()` detaches reference chains
- * from the original, potentially long-lived Promise, eliminating memory leaks.
- *
- * This approach can eliminate the memory leaks that otherwise come about from
- * repeated `race()` or `any()` calls invoking `.then()` and `.catch()` multiple
- * times on the same long-lived native Promise (subscriptions which can never be
- * cleaned up).
- *
- * `Unpromise.race(promises)` is a reference implementation of `Promise.race`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.any(promises)` is a reference implementation of `Promise.any`
- * avoiding memory leaks when using long-lived unsettled Promises.
- *
- * `Unpromise.resolve(promise)` returns an ephemeral `SubscribedPromise<T>` for
- * any given `Promise<T>` facilitating arbitrary async/await patterns. Behind
- * the scenes, `resolve` is implemented simply as
- * `Unpromise.proxy(promise).subscribe()`. Don't forget to call `.unsubscribe()`
- * to tidy up!
- *
- */ class Unpromise {
-    /** Create a promise that mitigates uncontrolled subscription to a long-lived
-   * Promise via .then() and .catch() - otherwise a source of memory leaks.
-   *
-   * The returned promise has an `unsubscribe()` method which can be called when
-   * the Promise is no longer being tracked by application logic, and which
-   * ensures that there is no reference chain from the original promise to the
-   * new one, and therefore no memory leak.
-   *
-   * If original promise has not yet settled, this adds a new unique promise
-   * that listens to then/catch events, along with an `unsubscribe()` method to
-   * detach it.
-   *
-   * If original promise has settled, then creates a new Promise.resolve() or
-   * Promise.reject() and provided unsubscribe is a noop.
-   *
-   * If you call `unsubscribe()` before the returned Promise has settled, it
-   * will never settle.
-   */ subscribe() {
-        // in all cases we will combine some promise with its unsubscribe function
-        let promise;
-        let unsubscribe;
-        const { settlement } = this;
-        if (settlement === null) {
-            // not yet settled - subscribe new promise. Expect eventual settlement
-            if (this.subscribers === null) {
-                // invariant - it is not settled, so it must have subscribers
-                throw new Error("Unpromise settled but still has subscribers");
-            }
-            const subscriber = withResolvers();
-            this.subscribers = listWithMember(this.subscribers, subscriber);
-            promise = subscriber.promise;
-            unsubscribe = ()=>{
-                if (this.subscribers !== null) {
-                    this.subscribers = listWithoutMember(this.subscribers, subscriber);
-                }
-            };
-        } else {
-            // settled - don't create subscribed promise. Just resolve or reject
-            const { status } = settlement;
-            if (status === "fulfilled") {
-                promise = Promise.resolve(settlement.value);
-            } else {
-                promise = Promise.reject(settlement.reason);
-            }
-            unsubscribe = NOOP;
-        }
-        // extend promise signature with the extra method
-        return Object.assign(promise, {
-            unsubscribe
-        });
-    }
-    /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */ then(onfulfilled, onrejected) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.then(onfulfilled, onrejected), {
-            unsubscribe
-        });
-    }
-    catch(onrejected) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.catch(onrejected), {
-            unsubscribe
-        });
-    }
-    finally(onfinally) {
-        const subscribed = this.subscribe();
-        const { unsubscribe } = subscribed;
-        return Object.assign(subscribed.finally(onfinally), {
-            unsubscribe
-        });
-    }
-    /** Unpromise STATIC METHODS */ /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
-   * of the provided Promise reference) */ static proxy(promise) {
-        const cached = Unpromise.getSubscribablePromise(promise);
-        return typeof cached !== "undefined" ? cached : Unpromise.createSubscribablePromise(promise);
-    }
-    /** Create and store an Unpromise keyed by an original Promise. */ static createSubscribablePromise(promise) {
-        const created = new Unpromise(promise);
-        subscribableCache.set(promise, created); // resolve promise to unpromise
-        subscribableCache.set(created, created); // resolve the unpromise to itself
-        return created;
-    }
-    /** Retrieve a previously-created Unpromise keyed by an original Promise. */ static getSubscribablePromise(promise) {
-        return subscribableCache.get(promise);
-    }
-    /** Promise STATIC METHODS */ /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
-   * it (that can be later unsubscribed to eliminate Memory leaks) */ static resolve(value) {
-        const promise = typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" ? value : Promise.resolve(value);
-        return Unpromise.proxy(promise).subscribe();
-    }
-    static async any(values) {
-        const valuesArray = Array.isArray(values) ? values : [
-            ...values
-        ];
-        const subscribedPromises = valuesArray.map(Unpromise.resolve);
-        try {
-            return await Promise.any(subscribedPromises);
-        } finally{
-            subscribedPromises.forEach(({ unsubscribe })=>{
-                unsubscribe();
-            });
-        }
-    }
-    static async race(values) {
-        const valuesArray = Array.isArray(values) ? values : [
-            ...values
-        ];
-        const subscribedPromises = valuesArray.map(Unpromise.resolve);
-        try {
-            return await Promise.race(subscribedPromises);
-        } finally{
-            subscribedPromises.forEach(({ unsubscribe })=>{
-                unsubscribe();
-            });
-        }
-    }
-    /** Create a race of SubscribedPromises that will fulfil to a single winning
-   * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
-   * accumulating .then() and .catch() subscribers. Allows simple logic to
-   * consume the result, like...
-   * ```ts
-   * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
-   * if(winner === promiseB){
-   *   const result = await promiseB;
-   *   // do the thing
-   * }
-   * ```
-   * */ static async raceReferences(promises) {
-        // map each promise to an eventual 1-tuple containing itself
-        const selfPromises = promises.map(resolveSelfTuple);
-        // now race them. They will fulfil to a readonly [P] or reject.
-        try {
-            return await Promise.race(selfPromises);
-        } finally{
-            for (const promise of selfPromises){
-                // unsubscribe proxy promises when the race is over to mitigate memory leaks
-                promise.unsubscribe();
-            }
-        }
-    }
-    constructor(arg){
-        /** INSTANCE IMPLEMENTATION */ /** The promise shadowed by this Unpromise<T>  */ _define_property(this, "promise", void 0);
-        /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-   * after the original promise settles - no further notifications will be issued. */ _define_property(this, "subscribers", []);
-        /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
-   * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
-   * can be returned, and therefore subscription can be bypassed. */ _define_property(this, "settlement", null);
-        /** TOSTRING SUPPORT */ _define_property(this, _computedKey1, "Unpromise");
-        // handle either a Promise or a Promise executor function
-        if (typeof arg === "function") {
-            this.promise = new Promise(arg);
-        } else {
-            this.promise = arg;
-        }
-        // subscribe for eventual fulfilment and rejection
-        // handle PromiseLike objects (that at least have .then)
-        const thenReturn = this.promise.then((value)=>{
-            // atomically record fulfilment and detach subscriber list
-            const { subscribers } = this;
-            this.subscribers = null;
-            this.settlement = {
-                status: "fulfilled",
-                value
-            };
-            // notify fulfilment to subscriber list
-            subscribers?.forEach(({ resolve })=>{
-                resolve(value);
-            });
-        });
-        // handle Promise (that also have a .catch behaviour)
-        if ("catch" in thenReturn) {
-            thenReturn.catch((reason)=>{
-                // atomically record rejection and detach subscriber list
-                const { subscribers } = this;
-                this.subscribers = null;
-                this.settlement = {
-                    status: "rejected",
-                    reason
-                };
-                // notify rejection to subscriber list
-                subscribers?.forEach(({ reject })=>{
-                    reject(reason);
-                });
-            });
-        }
-    }
-}
-/** Promises a 1-tuple containing the original promise when it resolves. Allows
- * awaiting the eventual Promise ***reference*** (easy to destructure and
- * exactly compare with ===). Avoids resolving to the Promise ***value*** (which
- * may be ambiguous and therefore hard to identify as the winner of a race).
- * You can call unsubscribe on the Promise to mitigate memory leaks.
- * */ function resolveSelfTuple(promise) {
-    return Unpromise.proxy(promise).then(()=>[
-            promise
-        ]);
-}
-/** VENDORED (Future) PROMISE UTILITIES */ /** Reference implementation of https://github.com/tc39/proposal-promise-with-resolvers */ function withResolvers() {
-    let resolve;
-    let reject;
-    const promise = new Promise((_resolve, _reject)=>{
-        resolve = _resolve;
-        reject = _reject;
-    });
-    return {
-        promise,
-        resolve,
-        reject
-    };
-}
-/** IMMUTABLE LIST OPERATIONS */ function listWithMember(arr, member) {
-    return [
-        ...arr,
-        member
-    ];
-}
-function listWithoutIndex(arr, index) {
-    return [
-        ...arr.slice(0, index),
-        ...arr.slice(index + 1)
-    ];
-}
-function listWithoutMember(arr, member) {
-    const index = arr.indexOf(member);
-    if (index !== -1) {
-        return listWithoutIndex(arr, index);
-    }
-    return arr;
-}
-
-export { Unpromise, resolveSelfTuple };