@highstate/designer 0.1.0

package/.output/server/node_modules/@iconify/vue/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@iconify/vue",
+  "description": "Iconify icon component for Vue 3.",
+  "author": "Vjacheslav Trushkin",
+  "version": "4.1.2",
+  "license": "MIT",
+  "bugs": "https://github.com/iconify/iconify/issues",
+  "homepage": "https://iconify.design/",
+  "funding": "https://github.com/sponsors/cyberalien",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iconify/iconify.git",
+    "directory": "components/vue"
+  },
+  "main": "dist/iconify.js",
+  "module": "dist/iconify.mjs",
+  "types": "dist/iconify.d.ts",
+  "exports": {
+    "./*": "./*",
+    ".": {
+      "import": "./dist/iconify.mjs",
+      "types": "./dist/iconify.d.ts",
+      "default": "./dist/iconify.js"
+    },
+    "./offline": {
+      "import": "./dist/offline.mjs",
+      "types": "./dist/offline.d.ts",
+      "default": "./dist/offline.js"
+    },
+    "./dist/offline": {
+      "import": "./dist/offline.mjs",
+      "types": "./dist/offline.d.ts",
+      "default": "./dist/offline.js"
+    }
+  },
+  "dependencies": {
+    "@iconify/types": "^2.0.0"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.24.4",
+    "@microsoft/api-extractor": "^7.43.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@types/jest": "^29.5.12",
+    "@vitejs/plugin-vue": "^4.6.2",
+    "@vue/test-utils": "^2.4.5",
+    "jsdom": "^21.1.2",
+    "rollup": "^3.29.4",
+    "typescript": "^5.4.5",
+    "vitest": "^0.29.8",
+    "vue": "^3.4.21",
+    "@iconify/core": "^2.0.2",
+    "@iconify/utils": "^2.1.23"
+  },
+  "peerDependencies": {
+    "vue": ">=3"
+  },
+  "scripts": {
+    "build": "node build",
+    "build:lib": "tsc -b",
+    "build:dist": "rollup -c rollup.config.mjs",
+    "prebuild:api": "api-extractor run --local --verbose --config api-extractor.offline.json",
+    "build:api": "api-extractor run --local --verbose --config api-extractor.iconify.json",
+    "test": "vitest"
+  }
+}

package/.output/server/node_modules/@trpc/client/dist/TRPCClientError-38f9a32a.mjs

@@ -0,0 +1,59 @@
+import { getCauseFromUnknown } from '@trpc/server/shared';
+import { i as isObject } from './transformResult-ace864b8.mjs';
+
+function isTRPCClientError(cause) {
+    return cause instanceof TRPCClientError || /**
+     * @deprecated
+     * Delete in next major
+     */ cause instanceof Error && cause.name === 'TRPCClientError';
+}
+function isTRPCErrorResponse(obj) {
+    return isObject(obj) && isObject(obj.error) && typeof obj.error.code === 'number' && typeof obj.error.message === 'string';
+}
+class TRPCClientError extends Error {
+    static from(_cause, opts = {}) {
+        const cause = _cause;
+        if (isTRPCClientError(cause)) {
+            if (opts.meta) {
+                // Decorate with meta error data
+                cause.meta = {
+                    ...cause.meta,
+                    ...opts.meta
+                };
+            }
+            return cause;
+        }
+        if (isTRPCErrorResponse(cause)) {
+            return new TRPCClientError(cause.error.message, {
+                ...opts,
+                result: cause
+            });
+        }
+        if (!(cause instanceof Error)) {
+            return new TRPCClientError('Unknown error', {
+                ...opts,
+                cause: cause
+            });
+        }
+        return new TRPCClientError(cause.message, {
+            ...opts,
+            cause: getCauseFromUnknown(cause)
+        });
+    }
+    constructor(message, opts){
+        const cause = opts?.cause;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        super(message, {
+            cause
+        });
+        this.meta = opts?.meta;
+        this.cause = cause;
+        this.shape = opts?.result?.error;
+        this.data = opts?.result?.error.data;
+        this.name = 'TRPCClientError';
+        Object.setPrototypeOf(this, TRPCClientError.prototype);
+    }
+}
+
+export { TRPCClientError as T };

package/.output/server/node_modules/@trpc/client/dist/httpBatchLink-d0f9eac9.mjs

@@ -0,0 +1,248 @@
+import { observable } from '@trpc/server/observable';
+import { t as transformResult } from './transformResult-ace864b8.mjs';
+import { T as TRPCClientError } from './TRPCClientError-38f9a32a.mjs';
+import { r as resolveHTTPLinkOptions, g as getUrl, j as jsonHttpRequester } from './httpUtils-b9d0cb48.mjs';
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ /**
+ * A function that should never be called unless we messed something up.
+ */ const throwFatalError = ()=>{
+    throw new Error('Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new');
+};
+/**
+ * Dataloader that's very inspired by https://github.com/graphql/dataloader
+ * Less configuration, no caching, and allows you to cancel requests
+ * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
+ */ function dataLoader(batchLoader) {
+    let pendingItems = null;
+    let dispatchTimer = null;
+    const destroyTimerAndPendingItems = ()=>{
+        clearTimeout(dispatchTimer);
+        dispatchTimer = null;
+        pendingItems = null;
+    };
+    /**
+   * Iterate through the items and split them into groups based on the `batchLoader`'s validate function
+   */ function groupItems(items) {
+        const groupedItems = [
+            []
+        ];
+        let index = 0;
+        while(true){
+            const item = items[index];
+            if (!item) {
+                break;
+            }
+            const lastGroup = groupedItems[groupedItems.length - 1];
+            if (item.aborted) {
+                // Item was aborted before it was dispatched
+                item.reject?.(new Error('Aborted'));
+                index++;
+                continue;
+            }
+            const isValid = batchLoader.validate(lastGroup.concat(item).map((it)=>it.key));
+            if (isValid) {
+                lastGroup.push(item);
+                index++;
+                continue;
+            }
+            if (lastGroup.length === 0) {
+                item.reject?.(new Error('Input is too big for a single dispatch'));
+                index++;
+                continue;
+            }
+            // Create new group, next iteration will try to add the item to that
+            groupedItems.push([]);
+        }
+        return groupedItems;
+    }
+    function dispatch() {
+        const groupedItems = groupItems(pendingItems);
+        destroyTimerAndPendingItems();
+        // Create batches for each group of items
+        for (const items of groupedItems){
+            if (!items.length) {
+                continue;
+            }
+            const batch = {
+                items,
+                cancel: throwFatalError
+            };
+            for (const item of items){
+                item.batch = batch;
+            }
+            const unitResolver = (index, value)=>{
+                const item = batch.items[index];
+                item.resolve?.(value);
+                item.batch = null;
+                item.reject = null;
+                item.resolve = null;
+            };
+            const { promise , cancel  } = batchLoader.fetch(batch.items.map((_item)=>_item.key), unitResolver);
+            batch.cancel = cancel;
+            promise.then((result)=>{
+                for(let i = 0; i < result.length; i++){
+                    const value = result[i];
+                    unitResolver(i, value);
+                }
+                for (const item of batch.items){
+                    item.reject?.(new Error('Missing result'));
+                    item.batch = null;
+                }
+            }).catch((cause)=>{
+                for (const item of batch.items){
+                    item.reject?.(cause);
+                    item.batch = null;
+                }
+            });
+        }
+    }
+    function load(key) {
+        const item = {
+            aborted: false,
+            key,
+            batch: null,
+            resolve: throwFatalError,
+            reject: throwFatalError
+        };
+        const promise = new Promise((resolve, reject)=>{
+            item.reject = reject;
+            item.resolve = resolve;
+            if (!pendingItems) {
+                pendingItems = [];
+            }
+            pendingItems.push(item);
+        });
+        if (!dispatchTimer) {
+            dispatchTimer = setTimeout(dispatch);
+        }
+        const cancel = ()=>{
+            item.aborted = true;
+            if (item.batch?.items.every((item)=>item.aborted)) {
+                // All items in the batch have been cancelled
+                item.batch.cancel();
+                item.batch = null;
+            }
+        };
+        return {
+            promise,
+            cancel
+        };
+    }
+    return {
+        load
+    };
+}
+
+/**
+ * @internal
+ */ function createHTTPBatchLink(requester) {
+    return function httpBatchLink(opts) {
+        const resolvedOpts = resolveHTTPLinkOptions(opts);
+        const maxURLLength = opts.maxURLLength ?? Infinity;
+        // initialized config
+        return (runtime)=>{
+            const batchLoader = (type)=>{
+                const validate = (batchOps)=>{
+                    if (maxURLLength === Infinity) {
+                        // escape hatch for quick calcs
+                        return true;
+                    }
+                    const path = batchOps.map((op)=>op.path).join(',');
+                    const inputs = batchOps.map((op)=>op.input);
+                    const url = getUrl({
+                        ...resolvedOpts,
+                        runtime,
+                        type,
+                        path,
+                        inputs
+                    });
+                    return url.length <= maxURLLength;
+                };
+                const fetch = requester({
+                    ...resolvedOpts,
+                    runtime,
+                    type,
+                    opts
+                });
+                return {
+                    validate,
+                    fetch
+                };
+            };
+            const query = dataLoader(batchLoader('query'));
+            const mutation = dataLoader(batchLoader('mutation'));
+            const subscription = dataLoader(batchLoader('subscription'));
+            const loaders = {
+                query,
+                subscription,
+                mutation
+            };
+            return ({ op  })=>{
+                return observable((observer)=>{
+                    const loader = loaders[op.type];
+                    const { promise , cancel  } = loader.load(op);
+                    let _res = undefined;
+                    promise.then((res)=>{
+                        _res = res;
+                        const transformed = transformResult(res.json, runtime);
+                        if (!transformed.ok) {
+                            observer.error(TRPCClientError.from(transformed.error, {
+                                meta: res.meta
+                            }));
+                            return;
+                        }
+                        observer.next({
+                            context: res.meta,
+                            result: transformed.result
+                        });
+                        observer.complete();
+                    }).catch((err)=>{
+                        observer.error(TRPCClientError.from(err, {
+                            meta: _res?.meta
+                        }));
+                    });
+                    return ()=>{
+                        cancel();
+                    };
+                });
+            };
+        };
+    };
+}
+
+const batchRequester = (requesterOpts)=>{
+    return (batchOps)=>{
+        const path = batchOps.map((op)=>op.path).join(',');
+        const inputs = batchOps.map((op)=>op.input);
+        const { promise , cancel  } = jsonHttpRequester({
+            ...requesterOpts,
+            path,
+            inputs,
+            headers () {
+                if (!requesterOpts.opts.headers) {
+                    return {};
+                }
+                if (typeof requesterOpts.opts.headers === 'function') {
+                    return requesterOpts.opts.headers({
+                        opList: batchOps
+                    });
+                }
+                return requesterOpts.opts.headers;
+            }
+        });
+        return {
+            promise: promise.then((res)=>{
+                const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(()=>res.json);
+                const result = resJSON.map((item)=>({
+                        meta: res.meta,
+                        json: item
+                    }));
+                return result;
+            }),
+            cancel
+        };
+    };
+};
+const httpBatchLink = createHTTPBatchLink(batchRequester);
+
+export { createHTTPBatchLink as c, httpBatchLink as h };

package/.output/server/node_modules/@trpc/client/dist/httpUtils-b9d0cb48.mjs

@@ -0,0 +1,144 @@
+import { T as TRPCClientError } from './TRPCClientError-38f9a32a.mjs';
+
+const isFunction = (fn)=>typeof fn === 'function';
+function getFetch(customFetchImpl) {
+    if (customFetchImpl) {
+        return customFetchImpl;
+    }
+    if (typeof window !== 'undefined' && isFunction(window.fetch)) {
+        return window.fetch;
+    }
+    if (typeof globalThis !== 'undefined' && isFunction(globalThis.fetch)) {
+        return globalThis.fetch;
+    }
+    throw new Error('No fetch implementation found');
+}
+
+function getAbortController(customAbortControllerImpl) {
+    if (customAbortControllerImpl) {
+        return customAbortControllerImpl;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof window !== 'undefined' && window.AbortController) {
+        return window.AbortController;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof globalThis !== 'undefined' && globalThis.AbortController) {
+        return globalThis.AbortController;
+    }
+    return null;
+}
+
+function resolveHTTPLinkOptions(opts) {
+    return {
+        url: opts.url.toString().replace(/\/$/, ''),
+        fetch: opts.fetch,
+        AbortController: getAbortController(opts.AbortController)
+    };
+}
+// https://github.com/trpc/trpc/pull/669
+function arrayToDict(array) {
+    const dict = {};
+    for(let index = 0; index < array.length; index++){
+        const element = array[index];
+        dict[index] = element;
+    }
+    return dict;
+}
+const METHOD = {
+    query: 'GET',
+    mutation: 'POST'
+};
+function getInput(opts) {
+    return 'input' in opts ? opts.runtime.transformer.serialize(opts.input) : arrayToDict(opts.inputs.map((_input)=>opts.runtime.transformer.serialize(_input)));
+}
+const getUrl = (opts)=>{
+    let url = opts.url + '/' + opts.path;
+    const queryParts = [];
+    if ('inputs' in opts) {
+        queryParts.push('batch=1');
+    }
+    if (opts.type === 'query') {
+        const input = getInput(opts);
+        if (input !== undefined) {
+            queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
+        }
+    }
+    if (queryParts.length) {
+        url += '?' + queryParts.join('&');
+    }
+    return url;
+};
+const getBody = (opts)=>{
+    if (opts.type === 'query') {
+        return undefined;
+    }
+    const input = getInput(opts);
+    return input !== undefined ? JSON.stringify(input) : undefined;
+};
+const jsonHttpRequester = (opts)=>{
+    return httpRequest({
+        ...opts,
+        contentTypeHeader: 'application/json',
+        getUrl,
+        getBody
+    });
+};
+async function fetchHTTPResponse(opts, ac) {
+    const url = opts.getUrl(opts);
+    const body = opts.getBody(opts);
+    const { type  } = opts;
+    const resolvedHeaders = await opts.headers();
+    /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
+        throw new Error('Subscriptions should use wsLink');
+    }
+    const headers = {
+        ...opts.contentTypeHeader ? {
+            'content-type': opts.contentTypeHeader
+        } : {},
+        ...opts.batchModeHeader ? {
+            'trpc-batch-mode': opts.batchModeHeader
+        } : {},
+        ...resolvedHeaders
+    };
+    return getFetch(opts.fetch)(url, {
+        method: METHOD[type],
+        signal: ac?.signal,
+        body: body,
+        headers
+    });
+}
+function httpRequest(opts) {
+    const ac = opts.AbortController ? new opts.AbortController() : null;
+    const meta = {};
+    let done = false;
+    const promise = new Promise((resolve, reject)=>{
+        fetchHTTPResponse(opts, ac).then((_res)=>{
+            meta.response = _res;
+            done = true;
+            return _res.json();
+        }).then((json)=>{
+            meta.responseJSON = json;
+            resolve({
+                json: json,
+                meta
+            });
+        }).catch((err)=>{
+            done = true;
+            reject(TRPCClientError.from(err, {
+                meta
+            }));
+        });
+    });
+    const cancel = ()=>{
+        if (!done) {
+            ac?.abort();
+        }
+    };
+    return {
+        promise,
+        cancel
+    };
+}
+
+export { getBody as a, getFetch as b, fetchHTTPResponse as f, getUrl as g, httpRequest as h, jsonHttpRequester as j, resolveHTTPLinkOptions as r };