@highstate/designer 0.2.2 → 0.3.3

package/.output/server/node_modules/@szmarczak/http-timer/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@szmarczak/http-timer",
+  "version": "4.0.6",
+  "description": "Timings for HTTP requests",
+  "main": "dist/source",
+  "engines": {
+    "node": ">=10"
+  },
+  "scripts": {
+    "test": "xo && tsc --noEmit && nyc ava",
+    "build": "del-cli dist && tsc",
+    "prepare": "npm run build",
+    "coveralls": "nyc report --reporter=text-lcov | coveralls"
+  },
+  "files": [
+    "dist/source"
+  ],
+  "keywords": [
+    "http",
+    "https",
+    "timer",
+    "timings"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/szmarczak/http-timer.git"
+  },
+  "author": "Szymon Marczak",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/szmarczak/http-timer/issues"
+  },
+  "homepage": "https://github.com/szmarczak/http-timer#readme",
+  "dependencies": {
+    "defer-to-connect": "^2.0.0"
+  },
+  "devDependencies": {
+    "@ava/typescript": "^2.0.0",
+    "@sindresorhus/tsconfig": "^1.0.2",
+    "@types/node": "^16.3.1",
+    "ava": "^3.15.0",
+    "coveralls": "^3.1.1",
+    "del-cli": "^3.0.1",
+    "http2-wrapper": "^2.0.7",
+    "nyc": "^15.1.0",
+    "p-event": "^4.2.0",
+    "typescript": "^4.3.5",
+    "xo": "^0.39.1"
+  },
+  "types": "dist/source",
+  "nyc": {
+    "extension": [
+      ".ts"
+    ],
+    "exclude": [
+      "**/tests/**"
+    ]
+  },
+  "xo": {
+    "rules": {
+      "@typescript-eslint/no-non-null-assertion": "off"
+    }
+  },
+  "ava": {
+    "typescript": {
+      "compile": false,
+      "rewritePaths": {
+        "tests/": "dist/tests/"
+      }
+    }
+  }
+}

package/.output/server/node_modules/@trpc/server/dist/http.mjs

@@ -0,0 +1,7 @@
+export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
+export { parseConnectionParamsFromString, parseConnectionParamsFromUnknown } from './unstable-core-do-not-import/http/parseConnectionParams.mjs';
+export { octetInputParser } from './unstable-core-do-not-import/http/contentTypeParsers.mjs';
+export { resolveResponse } from './unstable-core-do-not-import/http/resolveResponse.mjs';
+import './unstable-core-do-not-import/rootConfig.mjs';
+import './vendor/unpromise/unpromise.mjs';
+import './unstable-core-do-not-import/stream/utils/disposable.mjs';

package/.output/server/node_modules/@trpc/server/dist/index.mjs

@@ -0,0 +1,11 @@
+export { createFlatProxy as createTRPCFlatProxy } from './unstable-core-do-not-import/createProxy.mjs';
+export { getErrorShape } from './unstable-core-do-not-import/error/getErrorShape.mjs';
+export { TRPCError, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
+import './vendor/unpromise/unpromise.mjs';
+import './unstable-core-do-not-import/stream/utils/disposable.mjs';
+export { isTrackedEnvelope, sse, tracked } from './unstable-core-do-not-import/stream/tracked.mjs';
+export { transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
+export { initTRPC } from './unstable-core-do-not-import/initTRPC.mjs';
+export { experimental_standaloneMiddleware, experimental_standaloneMiddleware as experimental_trpcMiddleware } from './unstable-core-do-not-import/middleware.mjs';
+import './unstable-core-do-not-import/rootConfig.mjs';
+export { callProcedure, callProcedure as callTRPCProcedure } from './unstable-core-do-not-import/router.mjs';

package/.output/server/node_modules/@trpc/server/dist/observable/observable.mjs

@@ -0,0 +1,175 @@
+/** @public */ function isObservable(x) {
+    return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+/** @public */ function observable(subscribe) {
+    const self = {
+        subscribe (observer) {
+            let teardownRef = null;
+            let isDone = false;
+            let unsubscribed = false;
+            let teardownImmediately = false;
+            function unsubscribe() {
+                if (teardownRef === null) {
+                    teardownImmediately = true;
+                    return;
+                }
+                if (unsubscribed) {
+                    return;
+                }
+                unsubscribed = true;
+                if (typeof teardownRef === 'function') {
+                    teardownRef();
+                } else if (teardownRef) {
+                    teardownRef.unsubscribe();
+                }
+            }
+            teardownRef = subscribe({
+                next (value) {
+                    if (isDone) {
+                        return;
+                    }
+                    observer.next?.(value);
+                },
+                error (err) {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.error?.(err);
+                    unsubscribe();
+                },
+                complete () {
+                    if (isDone) {
+                        return;
+                    }
+                    isDone = true;
+                    observer.complete?.();
+                    unsubscribe();
+                }
+            });
+            if (teardownImmediately) {
+                unsubscribe();
+            }
+            return {
+                unsubscribe
+            };
+        },
+        pipe (...operations) {
+            return operations.reduce(pipeReducer, self);
+        }
+    };
+    return self;
+}
+function pipeReducer(prev, fn) {
+    return fn(prev);
+}
+/** @internal */ function observableToPromise(observable) {
+    const ac = new AbortController();
+    const promise = new Promise((resolve, reject)=>{
+        let isDone = false;
+        function onDone() {
+            if (isDone) {
+                return;
+            }
+            isDone = true;
+            obs$.unsubscribe();
+        }
+        ac.signal.addEventListener('abort', ()=>{
+            reject(ac.signal.reason);
+        });
+        const obs$ = observable.subscribe({
+            next (data) {
+                isDone = true;
+                resolve(data);
+                onDone();
+            },
+            error (data) {
+                reject(data);
+            },
+            complete () {
+                ac.abort();
+                onDone();
+            }
+        });
+    });
+    return promise;
+}
+/**
+ * @internal
+ */ function observableToReadableStream(observable, signal) {
+    let unsub = null;
+    const onAbort = ()=>{
+        unsub?.unsubscribe();
+        unsub = null;
+        signal.removeEventListener('abort', onAbort);
+    };
+    return new ReadableStream({
+        start (controller) {
+            unsub = observable.subscribe({
+                next (data) {
+                    controller.enqueue({
+                        ok: true,
+                        value: data
+                    });
+                },
+                error (error) {
+                    controller.enqueue({
+                        ok: false,
+                        error
+                    });
+                    controller.close();
+                },
+                complete () {
+                    controller.close();
+                }
+            });
+            if (signal.aborted) {
+                onAbort();
+            } else {
+                signal.addEventListener('abort', onAbort, {
+                    once: true
+                });
+            }
+        },
+        cancel () {
+            onAbort();
+        }
+    });
+}
+/** @internal */ function observableToAsyncIterable(observable, signal) {
+    const stream = observableToReadableStream(observable, signal);
+    const reader = stream.getReader();
+    const iterator = {
+        async next () {
+            const value = await reader.read();
+            if (value.done) {
+                return {
+                    value: undefined,
+                    done: true
+                };
+            }
+            const { value: result } = value;
+            if (!result.ok) {
+                throw result.error;
+            }
+            return {
+                value: result.value,
+                done: false
+            };
+        },
+        async return () {
+            await reader.cancel();
+            return {
+                value: undefined,
+                done: true
+            };
+        }
+    };
+    return {
+        [Symbol.asyncIterator] () {
+            return iterator;
+        }
+    };
+}
+
+export { isObservable, observable, observableToAsyncIterable, observableToPromise };

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

@@ -0,0 +1,73 @@
+const noop = ()=>{
+// noop
+};
+const freezeIfAvailable = (obj)=>{
+    if (Object.freeze) {
+        Object.freeze(obj);
+    }
+};
+function createInnerProxy(callback, path, memo) {
+    var _memo, _cacheKey;
+    const cacheKey = path.join('.');
+    (_memo = memo)[_cacheKey = cacheKey] ?? (_memo[_cacheKey] = new Proxy(noop, {
+        get (_obj, key) {
+            if (typeof key !== 'string' || key === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return createInnerProxy(callback, [
+                ...path,
+                key
+            ], memo);
+        },
+        apply (_1, _2, args) {
+            const lastOfPath = path[path.length - 1];
+            let opts = {
+                args,
+                path
+            };
+            // special handling for e.g. `trpc.hello.call(this, 'there')` and `trpc.hello.apply(this, ['there'])
+            if (lastOfPath === 'call') {
+                opts = {
+                    args: args.length >= 2 ? [
+                        args[1]
+                    ] : [],
+                    path: path.slice(0, -1)
+                };
+            } else if (lastOfPath === 'apply') {
+                opts = {
+                    args: args.length >= 2 ? args[1] : [],
+                    path: path.slice(0, -1)
+                };
+            }
+            freezeIfAvailable(opts.args);
+            freezeIfAvailable(opts.path);
+            return callback(opts);
+        }
+    }));
+    return memo[cacheKey];
+}
+/**
+ * Creates a proxy that calls the callback with the path and arguments
+ *
+ * @internal
+ */ const createRecursiveProxy = (callback)=>createInnerProxy(callback, [], Object.create(null));
+/**
+ * Used in place of `new Proxy` where each handler will map 1 level deep to another value.
+ *
+ * @internal
+ */ const createFlatProxy = (callback)=>{
+    return new Proxy(noop, {
+        get (_obj, name) {
+            if (typeof name !== 'string' || name === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            return callback(name);
+        }
+    });
+};
+
+export { createFlatProxy, createRecursiveProxy };

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

@@ -0,0 +1,78 @@
+import { isObject } from '../utils.mjs';
+
+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;
+}
+class UnknownCauseError extends Error {
+}
+function getCauseFromUnknown(cause) {
+    if (cause instanceof Error) {
+        return cause;
+    }
+    const type = typeof cause;
+    if (type === 'undefined' || type === 'function' || cause === null) {
+        return undefined;
+    }
+    // Primitive types just get wrapped in an error
+    if (type !== 'object') {
+        return new Error(String(cause));
+    }
+    // If it's an object, we'll create a synthetic error
+    if (isObject(cause)) {
+        const err = new UnknownCauseError();
+        for(const key in cause){
+            err[key] = cause[key];
+        }
+        return err;
+    }
+    return undefined;
+}
+function getTRPCErrorFromUnknown(cause) {
+    if (cause instanceof TRPCError) {
+        return cause;
+    }
+    if (cause instanceof Error && cause.name === 'TRPCError') {
+        // https://github.com/trpc/trpc/pull/4848
+        return cause;
+    }
+    const trpcError = new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        cause
+    });
+    // Inherit stack from error
+    if (cause instanceof Error && cause.stack) {
+        trpcError.stack = cause.stack;
+    }
+    return trpcError;
+}
+class TRPCError extends Error {
+    constructor(opts){
+        const cause = getCauseFromUnknown(opts.cause);
+        const message = opts.message ?? cause?.message ?? opts.code;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        super(message, {
+            cause
+        }), // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore override doesn't work in all environments due to "This member cannot have an 'override' modifier because it is not declared in the base class 'Error'"
+        _define_property(this, "cause", void 0), _define_property(this, "code", void 0);
+        this.code = opts.code;
+        this.name = 'TRPCError';
+        if (!this.cause) {
+            // < ES2022 / < Node 16.9.0 compatability
+            this.cause = cause;
+        }
+    }
+}
+
+export { TRPCError, getCauseFromUnknown, getTRPCErrorFromUnknown };

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

@@ -0,0 +1,5 @@
+const defaultFormatter = ({ shape })=>{
+    return shape;
+};
+
+export { defaultFormatter };

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

@@ -0,0 +1,29 @@
+import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode.mjs';
+import { TRPC_ERROR_CODES_BY_KEY } from '../rpc/codes.mjs';
+
+/**
+ * @internal
+ */ function getErrorShape(opts) {
+    const { path, error, config } = opts;
+    const { code } = opts.error;
+    const shape = {
+        message: error.message,
+        code: TRPC_ERROR_CODES_BY_KEY[code],
+        data: {
+            code,
+            httpStatus: getHTTPStatusCodeFromError(error)
+        }
+    };
+    if (config.isDev && typeof opts.error.stack === 'string') {
+        shape.data.stack = opts.error.stack;
+    }
+    if (typeof path === 'string') {
+        shape.data.path = path;
+    }
+    return config.errorFormatter({
+        ...opts,
+        shape
+    });
+}
+
+export { getErrorShape };

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

@@ -0,0 +1,224 @@
+import { TRPCError } from '../error/TRPCError.mjs';
+import { isObject, unsetMarker } from '../utils.mjs';
+import { parseConnectionParamsFromString } from './parseConnectionParams.mjs';
+
+/**
+ * Memoize a function that takes no arguments
+ * @internal
+ */ function memo(fn) {
+    let promise = null;
+    let value = unsetMarker;
+    return {
+        /**
+     * Lazily read the value
+     */ read: async ()=>{
+            if (value !== unsetMarker) {
+                return value;
+            }
+            if (promise === null) {
+                // dedupes promises and catches errors
+                promise = fn().catch((cause)=>{
+                    if (cause instanceof TRPCError) {
+                        throw cause;
+                    }
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: cause instanceof Error ? cause.message : 'Invalid input',
+                        cause
+                    });
+                });
+            }
+            value = await promise;
+            promise = null;
+            return value;
+        },
+        /**
+     * Get an already stored result
+     */ result: ()=>{
+            return value !== unsetMarker ? value : undefined;
+        }
+    };
+}
+const jsonContentTypeHandler = {
+    isMatch (req) {
+        return !!req.headers.get('content-type')?.startsWith('application/json');
+    },
+    parse (opts) {
+        const { req } = opts;
+        const isBatchCall = opts.searchParams.get('batch') === '1';
+        const paths = isBatchCall ? opts.path.split(',') : [
+            opts.path
+        ];
+        const getInputs = memo(async ()=>{
+            let inputs = undefined;
+            if (req.method === 'GET') {
+                const queryInput = opts.searchParams.get('input');
+                if (queryInput) {
+                    inputs = JSON.parse(queryInput);
+                }
+            } else {
+                inputs = await req.json();
+            }
+            if (inputs === undefined) {
+                return {};
+            }
+            if (!isBatchCall) {
+                return {
+                    0: opts.router._def._config.transformer.input.deserialize(inputs)
+                };
+            }
+            if (!isObject(inputs)) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: '"input" needs to be an object when doing a batch call'
+                });
+            }
+            const acc = {};
+            for (const index of paths.keys()){
+                const input = inputs[index];
+                if (input !== undefined) {
+                    acc[index] = opts.router._def._config.transformer.input.deserialize(input);
+                }
+            }
+            return acc;
+        });
+        const calls = paths.map((path, index)=>{
+            const procedure = opts.router._def.procedures[path] ?? null;
+            return {
+                path,
+                procedure,
+                getRawInput: async ()=>{
+                    const inputs = await getInputs.read();
+                    let input = inputs[index];
+                    if (procedure?._def.type === 'subscription') {
+                        const lastEventId = opts.headers.get('last-event-id') ?? opts.searchParams.get('lastEventId') ?? opts.searchParams.get('Last-Event-Id');
+                        if (lastEventId) {
+                            if (isObject(input)) {
+                                input = {
+                                    ...input,
+                                    lastEventId: lastEventId
+                                };
+                            } else {
+                                input ?? (input = {
+                                    lastEventId: lastEventId
+                                });
+                            }
+                        }
+                    }
+                    return input;
+                },
+                result: ()=>{
+                    return getInputs.result()?.[index];
+                }
+            };
+        });
+        const types = new Set(calls.map((call)=>call.procedure?._def.type).filter(Boolean));
+        /* istanbul ignore if -- @preserve */ if (types.size > 1) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Cannot mix procedure types in call: ${Array.from(types).join(', ')}`
+            });
+        }
+        const type = types.values().next().value ?? 'unknown';
+        const connectionParamsStr = opts.searchParams.get('connectionParams');
+        const info = {
+            isBatchCall,
+            accept: req.headers.get('trpc-accept'),
+            calls,
+            type,
+            connectionParams: connectionParamsStr === null ? null : parseConnectionParamsFromString(connectionParamsStr),
+            signal: req.signal
+        };
+        return info;
+    }
+};
+const formDataContentTypeHandler = {
+    isMatch (req) {
+        return !!req.headers.get('content-type')?.startsWith('multipart/form-data');
+    },
+    parse (opts) {
+        const { req } = opts;
+        if (req.method !== 'POST') {
+            throw new TRPCError({
+                code: 'METHOD_NOT_SUPPORTED',
+                message: 'Only POST requests are supported for multipart/form-data requests'
+            });
+        }
+        const getInputs = memo(async ()=>{
+            const fd = await req.formData();
+            return fd;
+        });
+        return {
+            accept: null,
+            calls: [
+                {
+                    path: opts.path,
+                    getRawInput: getInputs.read,
+                    result: getInputs.result,
+                    procedure: opts.router._def.procedures[opts.path] ?? null
+                }
+            ],
+            isBatchCall: false,
+            type: 'mutation',
+            connectionParams: null,
+            signal: req.signal
+        };
+    }
+};
+const octetStreamContentTypeHandler = {
+    isMatch (req) {
+        return !!req.headers.get('content-type')?.startsWith('application/octet-stream');
+    },
+    parse (opts) {
+        const { req } = opts;
+        if (req.method !== 'POST') {
+            throw new TRPCError({
+                code: 'METHOD_NOT_SUPPORTED',
+                message: 'Only POST requests are supported for application/octet-stream requests'
+            });
+        }
+        const getInputs = memo(async ()=>{
+            return req.body;
+        });
+        return {
+            calls: [
+                {
+                    path: opts.path,
+                    getRawInput: getInputs.read,
+                    result: getInputs.result,
+                    procedure: opts.router._def.procedures[opts.path] ?? null
+                }
+            ],
+            isBatchCall: false,
+            accept: null,
+            type: 'mutation',
+            connectionParams: null,
+            signal: req.signal
+        };
+    }
+};
+const handlers = [
+    jsonContentTypeHandler,
+    formDataContentTypeHandler,
+    octetStreamContentTypeHandler
+];
+function getContentTypeHandler(req) {
+    const handler = handlers.find((handler)=>handler.isMatch(req));
+    if (handler) {
+        return handler;
+    }
+    if (!handler && req.method === 'GET') {
+        // fallback to JSON for get requests so GET-requests can be opened in browser easily
+        return jsonContentTypeHandler;
+    }
+    throw new TRPCError({
+        code: 'UNSUPPORTED_MEDIA_TYPE',
+        message: req.headers.has('content-type') ? `Unsupported content-type "${req.headers.get('content-type')}` : 'Missing content-type header'
+    });
+}
+function getRequestInfo(opts) {
+    const handler = getContentTypeHandler(opts.req);
+    return handler.parse(opts);
+}
+
+export { getRequestInfo };

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

@@ -0,0 +1,12 @@
+const octetInputParser = {
+    _input: null,
+    _output: null,
+    parse (input) {
+        if (input instanceof ReadableStream) {
+            return input;
+        }
+        throw new Error(`Parsed input was expected to be a ReadableStream but was: ${typeof input}`);
+    }
+};
+
+export { octetInputParser };