@highstate/designer 0.1.0 → 0.2.1

package/.output/server/node_modules/@trpc/server/dist/resolveHTTPResponse-2fc435bb.mjs

@@ -1,291 +0,0 @@
-import { e as callProcedure } from './config-d5fdbd39.mjs';
-import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-98d44758.mjs';
-import { t as transformTRPCResponse, g as getErrorShape } from './transformTRPCResponse-1153b421.mjs';
-import { g as getJsonContentTypeInputs } from './contentType-9fd995d3.mjs';
-import { b as getHTTPStatusCode } from './index-f91d720c.mjs';
-
-const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
-    GET: 'query',
-    POST: 'mutation'
-};
-const fallbackContentTypeHandler = {
-    getInputs: getJsonContentTypeInputs
-};
-function initResponse(initOpts) {
-    const { ctx , paths , type , responseMeta , untransformedJSON , errors =[] ,  } = initOpts;
-    let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
-    const headers = {
-        'Content-Type': 'application/json'
-    };
-    const eagerGeneration = !untransformedJSON;
-    const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
-        untransformedJSON
-    ];
-    const meta = responseMeta?.({
-        ctx,
-        paths,
-        type,
-        data,
-        errors,
-        eagerGeneration
-    }) ?? {};
-    for (const [key, value] of Object.entries(meta.headers ?? {})){
-        headers[key] = value;
-    }
-    if (meta.status) {
-        status = meta.status;
-    }
-    return {
-        status,
-        headers
-    };
-}
-async function inputToProcedureCall(procedureOpts) {
-    const { opts , ctx , type , input , path  } = procedureOpts;
-    try {
-        const data = await callProcedure({
-            procedures: opts.router._def.procedures,
-            path,
-            rawInput: input,
-            ctx,
-            type
-        });
-        return {
-            result: {
-                data
-            }
-        };
-    } catch (cause) {
-        const error = getTRPCErrorFromUnknown(cause);
-        opts.onError?.({
-            error,
-            path,
-            input,
-            ctx,
-            type: type,
-            req: opts.req
-        });
-        return {
-            error: getErrorShape({
-                config: opts.router._def._config,
-                error,
-                type,
-                path,
-                input,
-                ctx
-            })
-        };
-    }
-}
-function caughtErrorToData(cause, errorOpts) {
-    const { router , req , onError  } = errorOpts.opts;
-    const error = getTRPCErrorFromUnknown(cause);
-    onError?.({
-        error,
-        path: errorOpts.path,
-        input: errorOpts.input,
-        ctx: errorOpts.ctx,
-        type: errorOpts.type,
-        req
-    });
-    const untransformedJSON = {
-        error: getErrorShape({
-            config: router._def._config,
-            error,
-            type: errorOpts.type,
-            path: errorOpts.path,
-            input: errorOpts.input,
-            ctx: errorOpts.ctx
-        })
-    };
-    const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
-    const body = JSON.stringify(transformedJSON);
-    return {
-        error,
-        untransformedJSON,
-        body
-    };
-}
-// implementation
-async function resolveHTTPResponse(opts) {
-    const { router , req , unstable_onHead , unstable_onChunk  } = opts;
-    if (req.method === 'HEAD') {
-        // can be used for lambda warmup
-        const headResponse = {
-            status: 204
-        };
-        unstable_onHead?.(headResponse, false);
-        unstable_onChunk?.([
-            -1,
-            ''
-        ]);
-        return headResponse;
-    }
-    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
-    const batchingEnabled = opts.batching?.enabled ?? true;
-    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
-    let ctx = undefined;
-    let paths;
-    const isBatchCall = !!req.query.get('batch');
-    const isStreamCall = isBatchCall && unstable_onHead && unstable_onChunk && req.headers['trpc-batch-mode'] === 'stream';
-    try {
-        // we create context first so that (unless `createContext()` throws)
-        // error handler may access context information
-        //
-        // this way even if the client sends malformed input that might cause an exception:
-        //  - `opts.error` has value,
-        //  - batching is not enabled,
-        //  - `type` is unknown,
-        //  - `getInputs` throws because of malformed JSON,
-        // context value is still available to the error handler
-        ctx = await opts.createContext();
-        if (opts.error) {
-            throw opts.error;
-        }
-        if (isBatchCall && !batchingEnabled) {
-            throw new Error(`Batching is not enabled on the server`);
-        }
-        /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
-            throw new TRPCError({
-                message: 'Subscriptions should use wsLink',
-                code: 'METHOD_NOT_SUPPORTED'
-            });
-        }
-        if (type === 'unknown') {
-            throw new TRPCError({
-                message: `Unexpected request method ${req.method}`,
-                code: 'METHOD_NOT_SUPPORTED'
-            });
-        }
-        const inputs = await contentTypeHandler.getInputs({
-            isBatchCall,
-            req,
-            router,
-            preprocessedBody: opts.preprocessedBody ?? false
-        });
-        paths = isBatchCall ? decodeURIComponent(opts.path).split(',') : [
-            opts.path
-        ];
-        const promises = paths.map((path, index)=>inputToProcedureCall({
-                opts,
-                ctx,
-                type,
-                input: inputs[index],
-                path
-            }));
-        if (!isStreamCall) {
-            /**
-       * Non-streaming response:
-       * - await all responses in parallel, blocking on the slowest one
-       * - create headers with known response body
-       * - return a complete HTTPResponse
-       */ const untransformedJSON = await Promise.all(promises);
-            const errors = untransformedJSON.flatMap((response)=>'error' in response ? [
-                    response.error
-                ] : []);
-            const headResponse1 = initResponse({
-                ctx,
-                paths,
-                type,
-                responseMeta: opts.responseMeta,
-                untransformedJSON,
-                errors
-            });
-            unstable_onHead?.(headResponse1, false);
-            // return body stuff
-            const result = isBatchCall ? untransformedJSON : untransformedJSON[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
-            const transformedJSON = transformTRPCResponse(router._def._config, result);
-            const body = JSON.stringify(transformedJSON);
-            unstable_onChunk?.([
-                -1,
-                body
-            ]);
-            return {
-                status: headResponse1.status,
-                headers: headResponse1.headers,
-                body
-            };
-        }
-        /**
-     * Streaming response:
-     * - block on none, call `onChunk` as soon as each response is ready
-     * - create headers with minimal data (cannot know the response body in advance)
-     * - return void
-     */ const headResponse2 = initResponse({
-            ctx,
-            paths,
-            type,
-            responseMeta: opts.responseMeta
-        });
-        unstable_onHead(headResponse2, true);
-        const indexedPromises = new Map(promises.map((promise, index)=>[
-                index,
-                promise.then((r)=>[
-                        index,
-                        r
-                    ])
-            ]));
-        for (const _ of paths){
-            const [index, untransformedJSON1] = await Promise.race(indexedPromises.values());
-            indexedPromises.delete(index);
-            try {
-                const transformedJSON1 = transformTRPCResponse(router._def._config, untransformedJSON1);
-                const body1 = JSON.stringify(transformedJSON1);
-                unstable_onChunk([
-                    index,
-                    body1
-                ]);
-            } catch (cause) {
-                const path = paths[index];
-                const input = inputs[index];
-                const { body: body2  } = caughtErrorToData(cause, {
-                    opts,
-                    ctx,
-                    type,
-                    path,
-                    input
-                });
-                unstable_onChunk([
-                    index,
-                    body2
-                ]);
-            }
-        }
-        return;
-    } catch (cause1) {
-        // we get here if
-        // - batching is called when it's not enabled
-        // - `createContext()` throws
-        // - `router._def._config.transformer.output.serialize()` throws
-        // - post body is too large
-        // - input deserialization fails
-        // - `errorFormatter` return value is malformed
-        const { error , untransformedJSON: untransformedJSON2 , body: body3  } = caughtErrorToData(cause1, {
-            opts,
-            ctx,
-            type
-        });
-        const headResponse3 = initResponse({
-            ctx,
-            paths,
-            type,
-            responseMeta: opts.responseMeta,
-            untransformedJSON: untransformedJSON2,
-            errors: [
-                error
-            ]
-        });
-        unstable_onHead?.(headResponse3, false);
-        unstable_onChunk?.([
-            -1,
-            body3
-        ]);
-        return {
-            status: headResponse3.status,
-            headers: headResponse3.headers,
-            body: body3
-        };
-    }
-}
-
-export { resolveHTTPResponse as r };

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

@@ -1,4 +0,0 @@
-export { c as createFlatProxy, a as createRecursiveProxy } from '../index-f91d720c.mjs';
-export { g as getErrorShape, t as transformTRPCResponse } from '../transformTRPCResponse-1153b421.mjs';
-export { g as getCauseFromUnknown } from '../getCauseFromUnknown-2d66414a.mjs';
-import '../codes-c924c3db.mjs';

package/.output/server/node_modules/@trpc/server/dist/transformTRPCResponse-1153b421.mjs

@@ -1,53 +0,0 @@
-import { g as getHTTPStatusCodeFromError } from './index-f91d720c.mjs';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-c924c3db.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
-    });
-}
-
-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);
-}
-
-export { getErrorShape as g, transformTRPCResponse as t };

package/.output/server/node_modules/@vue-flow/background/dist/vue-flow-background.mjs

@@ -1,126 +0,0 @@
-import { h, defineComponent, computed, toRef, openBlock, createElementBlock, normalizeStyle, renderSlot, createElementVNode, unref, createBlock, createCommentVNode } from "vue";
-import { useVueFlow } from "@vue-flow/core";
-var BackgroundVariant = /* @__PURE__ */ ((BackgroundVariant2) => {
-  BackgroundVariant2["Lines"] = "lines";
-  BackgroundVariant2["Dots"] = "dots";
-  return BackgroundVariant2;
-})(BackgroundVariant || {});
-const LinePattern = function({ dimensions, size, color }) {
-  return h("path", {
-    "stroke": color,
-    "stroke-width": size,
-    "d": `M${dimensions[0] / 2} 0 V${dimensions[1]} M0 ${dimensions[1] / 2} H${dimensions[0]}`
-  });
-};
-const DotPattern = function({ radius, color }) {
-  return h("circle", { cx: radius, cy: radius, r: radius, fill: color });
-};
-({
-  [BackgroundVariant.Lines]: LinePattern,
-  [BackgroundVariant.Dots]: DotPattern
-});
-const DefaultBgColors = {
-  [BackgroundVariant.Dots]: "#81818a",
-  [BackgroundVariant.Lines]: "#eee"
-};
-const _hoisted_1 = ["id", "x", "y", "width", "height", "patternTransform"];
-const _hoisted_2 = {
-  key: 2,
-  height: "100",
-  width: "100"
-};
-const _hoisted_3 = ["fill"];
-const _hoisted_4 = ["x", "y", "fill"];
-const __default__ = {
-  name: "Background",
-  compatConfig: { MODE: 3 }
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
-  props: {
-    id: {},
-    variant: { default: () => BackgroundVariant.Dots },
-    gap: { default: 20 },
-    size: { default: 1 },
-    lineWidth: { default: 1 },
-    patternColor: {},
-    color: {},
-    bgColor: {},
-    height: { default: 100 },
-    width: { default: 100 },
-    x: { default: 0 },
-    y: { default: 0 },
-    offset: { default: 0 }
-  },
-  setup(__props) {
-    const { id: vueFlowId, viewport } = useVueFlow();
-    const background = computed(() => {
-      const zoom = viewport.value.zoom;
-      const [gapX, gapY] = Array.isArray(__props.gap) ? __props.gap : [__props.gap, __props.gap];
-      const scaledGap = [gapX * zoom || 1, gapY * zoom || 1];
-      const scaledSize = __props.size * zoom;
-      const [offsetX, offsetY] = Array.isArray(__props.offset) ? __props.offset : [__props.offset, __props.offset];
-      const scaledOffset = [offsetX * zoom || 1 + scaledGap[0] / 2, offsetY * zoom || 1 + scaledGap[1] / 2];
-      return {
-        scaledGap,
-        offset: scaledOffset,
-        size: scaledSize
-      };
-    });
-    const patternId = toRef(() => `pattern-${vueFlowId}${__props.id ? `-${__props.id}` : ""}`);
-    const patternColor = toRef(() => __props.color || __props.patternColor || DefaultBgColors[__props.variant || BackgroundVariant.Dots]);
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("svg", {
-        class: "vue-flow__background vue-flow__container",
-        style: normalizeStyle({
-          height: `${_ctx.height > 100 ? 100 : _ctx.height}%`,
-          width: `${_ctx.width > 100 ? 100 : _ctx.width}%`
-        })
-      }, [
-        renderSlot(_ctx.$slots, "pattern-container", { id: patternId.value }, () => [
-          createElementVNode("pattern", {
-            id: patternId.value,
-            x: unref(viewport).x % background.value.scaledGap[0],
-            y: unref(viewport).y % background.value.scaledGap[1],
-            width: background.value.scaledGap[0],
-            height: background.value.scaledGap[1],
-            patternTransform: `translate(-${background.value.offset[0]},-${background.value.offset[1]})`,
-            patternUnits: "userSpaceOnUse"
-          }, [
-            renderSlot(_ctx.$slots, "pattern", {}, () => [
-              _ctx.variant === unref(BackgroundVariant).Lines ? (openBlock(), createBlock(unref(LinePattern), {
-                key: 0,
-                size: _ctx.lineWidth,
-                color: patternColor.value,
-                dimensions: background.value.scaledGap
-              }, null, 8, ["size", "color", "dimensions"])) : _ctx.variant === unref(BackgroundVariant).Dots ? (openBlock(), createBlock(unref(DotPattern), {
-                key: 1,
-                color: patternColor.value,
-                radius: background.value.size / 2
-              }, null, 8, ["color", "radius"])) : createCommentVNode("", true),
-              _ctx.bgColor ? (openBlock(), createElementBlock("svg", _hoisted_2, [
-                createElementVNode("rect", {
-                  width: "100%",
-                  height: "100%",
-                  fill: _ctx.bgColor
-                }, null, 8, _hoisted_3)
-              ])) : createCommentVNode("", true)
-            ])
-          ], 8, _hoisted_1)
-        ]),
-        createElementVNode("rect", {
-          x: _ctx.x,
-          y: _ctx.y,
-          width: "100%",
-          height: "100%",
-          fill: `url(#${patternId.value})`
-        }, null, 8, _hoisted_4),
-        renderSlot(_ctx.$slots, "default", { id: patternId.value })
-      ], 4);
-    };
-  }
-});
-export {
-  _sfc_main as Background,
-  BackgroundVariant
-};

package/.output/server/node_modules/@vue-flow/background/package.json

@@ -1,73 +0,0 @@
-{
-  "name": "@vue-flow/background",
-  "version": "1.3.2",
-  "private": false,
-  "license": "MIT",
-  "author": "Burak Cakmakoglu<78412429+bcakmakoglu@users.noreply.github.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/bcakmakoglu/vue-flow/packages/plugins/background"
-  },
-  "homepage": "https://github.com/bcakmakoglu/vue-flow#readme",
-  "bugs": {
-    "url": "https://github.com/bcakmakoglu/vue-flow/issues"
-  },
-  "keywords": [
-    "vue",
-    "flow",
-    "diagram",
-    "editor",
-    "graph",
-    "node",
-    "link",
-    "port",
-    "slot",
-    "vue3",
-    "composition-api",
-    "vue-flow",
-    "vueflow",
-    "typescript"
-  ],
-  "main": "./dist/vue-flow-background.js",
-  "module": "./dist/vue-flow-background.mjs",
-  "types": "./dist/index.d.ts",
-  "unpkg": "./dist/vue-flow-background.iife.js",
-  "jsdelivr": "./dist/vue-flow-background.iife.js",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/vue-flow-background.mjs",
-      "require": "./dist/vue-flow-background.js"
-    }
-  },
-  "files": [
-    "dist",
-    "*.d.ts"
-  ],
-  "sideEffects": false,
-  "peerDependencies": {
-    "@vue-flow/core": "^1.23.0",
-    "vue": "^3.3.0"
-  },
-  "devDependencies": {
-    "vue-tsc": "^1.8.16",
-    "@tooling/eslint-config": "0.0.0",
-    "@tooling/tsconfig": "0.0.0",
-    "@tooling/vite-config": "0.0.0",
-    "@vue-flow/core": "1.41.5"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "scripts": {
-    "dev": "pnpm types:watch & pnpm build:watch",
-    "build": "vite build",
-    "build:watch": "vite build --watch",
-    "types": "vue-tsc --declaration --emitDeclarationOnly && pnpm lint:dist",
-    "types:watch": "vue-tsc --declaration --emitDeclarationOnly --watch",
-    "lint": "eslint --ext .js,.ts,.vue ./",
-    "lint:dist": "eslint --ext \".ts,.tsx\" -c .eslintrc.js --fix --ignore-pattern !**/*  ./dist",
-    "test": "exit 0"
-  }
-}