@highstate/designer 0.9.14 → 0.9.16

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