@highstate/designer 0.7.1 → 0.7.3

package/.output/server/node_modules/@babel/parser/package.json

@@ -1,50 +0,0 @@
-{
-  "name": "@babel/parser",
-  "version": "7.27.0",
-  "description": "A JavaScript parser",
-  "author": "The Babel Team (https://babel.dev/team)",
-  "homepage": "https://babel.dev/docs/en/next/babel-parser",
-  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "babel",
-    "javascript",
-    "parser",
-    "tc39",
-    "ecmascript",
-    "@babel/parser"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-parser"
-  },
-  "main": "./lib/index.js",
-  "types": "./typings/babel-parser.d.ts",
-  "files": [
-    "bin",
-    "lib",
-    "typings/babel-parser.d.ts",
-    "index.cjs"
-  ],
-  "engines": {
-    "node": ">=6.0.0"
-  },
-  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
-  "dependencies": {
-    "@babel/types": "^7.27.0"
-  },
-  "devDependencies": {
-    "@babel/code-frame": "^7.26.2",
-    "@babel/helper-check-duplicate-nodes": "^7.25.9",
-    "@babel/helper-fixtures": "^7.26.0",
-    "@babel/helper-string-parser": "^7.25.9",
-    "@babel/helper-validator-identifier": "^7.25.9",
-    "charcodes": "^0.2.0"
-  },
-  "bin": "./bin/babel-parser.js",
-  "type": "commonjs"
-}

package/.output/server/node_modules/@trpc/server/dist/adapters/fetch/fetchRequestHandler.mjs

@@ -1,74 +0,0 @@
-import { 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';
-
-/**
- * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
- *
- * @example
- * ```ts
- * import type { AnyTRPCRouter } from '@trpc/server'
- * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
- * ```
- */ // @trpc/server
-const trimSlashes = (path)=>{
-    path = path.startsWith('/') ? path.slice(1) : path;
-    path = path.endsWith('/') ? path.slice(0, -1) : path;
-    return path;
-};
-async function fetchRequestHandler(opts) {
-    const resHeaders = new Headers();
-    const createContext = async (innerOpts)=>{
-        return opts.createContext?.({
-            req: opts.req,
-            resHeaders,
-            ...innerOpts
-        });
-    };
-    const url = new URL(opts.req.url);
-    const pathname = trimSlashes(url.pathname);
-    const endpoint = trimSlashes(opts.endpoint);
-    const path = trimSlashes(pathname.slice(endpoint.length));
-    return await resolveResponse({
-        ...opts,
-        req: opts.req,
-        createContext,
-        path,
-        error: null,
-        onError (o) {
-            opts?.onError?.({
-                ...o,
-                req: opts.req
-            });
-        },
-        responseMeta (data) {
-            const meta = opts.responseMeta?.(data);
-            if (meta?.headers) {
-                if (meta.headers instanceof Headers) {
-                    for (const [key, value] of meta.headers.entries()){
-                        resHeaders.append(key, value);
-                    }
-                } else {
-                    /**
-           * @deprecated, delete in v12
-           */ for (const [key, value] of Object.entries(meta.headers)){
-                        if (Array.isArray(value)) {
-                            for (const v of value){
-                                resHeaders.append(key, v);
-                            }
-                        } else if (typeof value === 'string') {
-                            resHeaders.set(key, value);
-                        }
-                    }
-                }
-            }
-            return {
-                headers: resHeaders,
-                status: meta?.status
-            };
-        }
-    });
-}
-
-export { fetchRequestHandler };

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

@@ -1 +0,0 @@
-export { fetchRequestHandler } from './fetchRequestHandler.mjs';

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/incomingMessageToRequest.mjs

@@ -1,119 +0,0 @@
-import { TRPCError } from '../../unstable-core-do-not-import/error/TRPCError.mjs';
-import '../../vendor/unpromise/unpromise.mjs';
-import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
-import '../../unstable-core-do-not-import/rootConfig.mjs';
-
-function createBody(req, opts) {
-    // Some adapters will pre-parse the body and add it to the request object
-    if ('body' in req) {
-        if (req.body === undefined) {
-            // If body property exists but is undefined, return undefined
-            return undefined;
-        }
-        // If the body is already a string, return it directly
-        if (typeof req.body === 'string') {
-            return req.body;
-        }
-        // If body exists but isn't a string, stringify it as JSON
-        return JSON.stringify(req.body);
-    }
-    let size = 0;
-    let hasClosed = false;
-    return new ReadableStream({
-        start (controller) {
-            const onData = (chunk)=>{
-                size += chunk.length;
-                if (!opts.maxBodySize || size <= opts.maxBodySize) {
-                    controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
-                    return;
-                }
-                controller.error(new TRPCError({
-                    code: 'PAYLOAD_TOO_LARGE'
-                }));
-                hasClosed = true;
-                req.off('data', onData);
-                req.off('end', onEnd);
-            };
-            const onEnd = ()=>{
-                if (hasClosed) {
-                    return;
-                }
-                hasClosed = true;
-                req.off('data', onData);
-                req.off('end', onEnd);
-                controller.close();
-            };
-            req.on('data', onData);
-            req.on('end', onEnd);
-        },
-        cancel () {
-            req.destroy();
-        }
-    });
-}
-function createURL(req) {
-    try {
-        const protocol = // http2
-        req.headers[':scheme'] && req.headers[':scheme'] === 'https' || // http1
-        req.socket && 'encrypted' in req.socket && req.socket.encrypted ? 'https:' : 'http:';
-        const host = req.headers.host ?? req.headers[':authority'] ?? 'localhost';
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return new URL(req.url, `${protocol}//${host}`);
-    } catch (cause) {
-        throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: 'Invalid URL',
-            cause
-        });
-    }
-}
-function createHeaders(incoming) {
-    const headers = new Headers();
-    for(const key in incoming){
-        const value = incoming[key];
-        if (typeof key === 'string' && key.startsWith(':')) {
-            continue;
-        }
-        if (Array.isArray(value)) {
-            for (const item of value){
-                headers.append(key, item);
-            }
-        } else if (value != null) {
-            headers.append(key, value);
-        }
-    }
-    return headers;
-}
-/**
- * Convert an [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
- */ function incomingMessageToRequest(req, res, opts) {
-    const ac = new AbortController();
-    const onAbort = ()=>{
-        res.off('close', onAbort);
-        req.socket?.off?.('close', onAbort);
-        // abort the request
-        ac.abort();
-    };
-    res.once('close', onAbort);
-    req.socket?.once?.('close', onAbort);
-    // Get host from either regular header or HTTP/2 pseudo-header
-    const url = createURL(req);
-    const init = {
-        headers: createHeaders(req.headers),
-        method: req.method,
-        signal: ac.signal
-    };
-    if (req.method !== 'GET' && req.method !== 'HEAD') {
-        init.body = createBody(req, opts);
-        // init.duplex = 'half' must be set when body is a ReadableStream, and Node follows the spec.
-        // However, this property is not defined in the TypeScript types for RequestInit, so we have
-        // to cast it here in order to set it without a type error.
-        // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex
-        // @ts-expect-error this is fine
-        init.duplex = 'half';
-    }
-    const request = new Request(url, init);
-    return request;
-}
-
-export { createURL, incomingMessageToRequest };

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/index.mjs

@@ -1,2 +0,0 @@
-export { internal_exceptionHandler, nodeHTTPRequestHandler } from './nodeHTTPRequestHandler.mjs';
-export { createURL, incomingMessageToRequest } from './incomingMessageToRequest.mjs';

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/nodeHTTPRequestHandler.mjs

@@ -1,92 +0,0 @@
-import { getErrorShape } from '../../unstable-core-do-not-import/error/getErrorShape.mjs';
-import { getTRPCErrorFromUnknown } from '../../unstable-core-do-not-import/error/TRPCError.mjs';
-import { transformTRPCResponse } from '../../unstable-core-do-not-import/transformer.mjs';
-import { run } from '../../unstable-core-do-not-import/utils.mjs';
-import { 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';
-import { incomingMessageToRequest } from './incomingMessageToRequest.mjs';
-import { writeResponse } from './writeResponse.mjs';
-
-/**
- * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
- *
- * @example
- * ```ts
- * import type { AnyTRPCRouter } from '@trpc/server'
- * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
- * ```
- */ // @trpc/server
-/**
- * @internal
- */ function internal_exceptionHandler(opts) {
-    return (cause)=>{
-        const { res, req } = opts;
-        const error = getTRPCErrorFromUnknown(cause);
-        const shape = getErrorShape({
-            config: opts.router._def._config,
-            error,
-            type: 'unknown',
-            path: undefined,
-            input: undefined,
-            ctx: undefined
-        });
-        opts.onError?.({
-            req,
-            error,
-            type: 'unknown',
-            path: undefined,
-            input: undefined,
-            ctx: undefined
-        });
-        const transformed = transformTRPCResponse(opts.router._def._config, {
-            error: shape
-        });
-        res.statusCode = shape.data.httpStatus;
-        res.end(JSON.stringify(transformed));
-    };
-}
-/**
- * @remark the promise never rejects
- */ async function nodeHTTPRequestHandler(opts) {
-    return new Promise((resolve)=>{
-        const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
-        opts.res.once('finish', ()=>{
-            resolve();
-        });
-        return handleViaMiddleware(opts.req, opts.res, (err)=>{
-            run(async ()=>{
-                const request = incomingMessageToRequest(opts.req, opts.res, {
-                    maxBodySize: opts.maxBodySize ?? null
-                });
-                // Build tRPC dependencies
-                const createContext = async (innerOpts)=>{
-                    return await opts.createContext?.({
-                        ...opts,
-                        ...innerOpts
-                    });
-                };
-                const response = await resolveResponse({
-                    ...opts,
-                    req: request,
-                    error: err ? getTRPCErrorFromUnknown(err) : null,
-                    createContext,
-                    onError (o) {
-                        opts?.onError?.({
-                            ...o,
-                            req: opts.req
-                        });
-                    }
-                });
-                await writeResponse({
-                    request,
-                    response,
-                    rawResponse: opts.res
-                });
-            }).catch(internal_exceptionHandler(opts));
-        });
-    });
-}
-
-export { internal_exceptionHandler, nodeHTTPRequestHandler };

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/writeResponse.mjs

@@ -1,79 +0,0 @@
-import { isAbortError } from '../../unstable-core-do-not-import/http/abortError.mjs';
-import '../../vendor/unpromise/unpromise.mjs';
-import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
-import '../../unstable-core-do-not-import/rootConfig.mjs';
-
-// eslint-disable-next-line no-restricted-imports
-async function writeResponseBodyChunk(res, chunk) {
-    // useful for debugging 🙃
-    // console.debug('writing', new TextDecoder().decode(chunk));
-    if (res.write(chunk) === false) {
-        await new Promise((resolve, reject)=>{
-            const onError = (err)=>{
-                reject(err);
-                cleanup();
-            };
-            const onDrain = ()=>{
-                resolve();
-                cleanup();
-            };
-            const cleanup = ()=>{
-                res.off('error', onError);
-                res.off('drain', onDrain);
-            };
-            res.once('error', onError);
-            res.once('drain', onDrain);
-        });
-    }
-}
-/**
- * @internal
- */ async function writeResponseBody(opts) {
-    const { res } = opts;
-    try {
-        const writableStream = new WritableStream({
-            async write (chunk) {
-                await writeResponseBodyChunk(res, chunk);
-                res.flush?.();
-            }
-        });
-        await opts.body.pipeTo(writableStream, {
-            signal: opts.signal
-        });
-    } catch (err) {
-        if (isAbortError(err)) {
-            return;
-        }
-        throw err;
-    }
-}
-/**
- * @internal
- */ async function writeResponse(opts) {
-    const { response, rawResponse } = opts;
-    // Only override status code if it hasn't been explicitly set in a procedure etc
-    if (rawResponse.statusCode === 200) {
-        rawResponse.statusCode = response.status;
-    }
-    for (const [key, value] of response.headers){
-        rawResponse.setHeader(key, value);
-    }
-    try {
-        if (response.body) {
-            await writeResponseBody({
-                res: rawResponse,
-                signal: opts.request.signal,
-                body: response.body
-            });
-        }
-    } catch (err) {
-        if (!rawResponse.headersSent) {
-            rawResponse.statusCode = 500;
-        }
-        throw err;
-    } finally{
-        rawResponse.end();
-    }
-}
-
-export { writeResponse, writeResponseBody };

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

@@ -1,12 +0,0 @@
-export { createFlatProxy as createTRPCFlatProxy, createRecursiveProxy as createTRPCRecursiveProxy } 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';
-export { callProcedure as callTRPCProcedure, lazy as experimental_lazy, lazy } from './unstable-core-do-not-import/router.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';
-export { StandardSchemaV1Error } from './vendor/standard-schema-v1/error.mjs';
-import './unstable-core-do-not-import/rootConfig.mjs';

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

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

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