@highstate/designer 0.9.5 → 0.9.6

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

@@ -0,0 +1,50 @@
+{
+  "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

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

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

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

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

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

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

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