@lobb-js/studio 0.1.38 → 0.1.40

package/dist/Lobb.js

@@ -0,0 +1,358 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import qs from "qs";
+import { parseFunction } from "./utils";
+var Lobb = /** @class */ (function () {
+    function Lobb(lobbUrl) {
+        this.headers = [];
+        this.onResponseHandlers = [];
+        this.lobbUrl = lobbUrl;
+    }
+    Lobb.prototype.onResponse = function (callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.onResponseHandlers.push(callback);
+                return [2 /*return*/];
+            });
+        });
+    };
+    Lobb.prototype.setHeaders = function (headers) {
+        this.headers = headers;
+    };
+    Lobb.prototype.getHeaders = function () {
+        return this.headers;
+    };
+    Lobb.prototype.getMeta = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, metaResponse, meta;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/meta"), {
+                            headers: this.headers,
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2:
+                        metaResponse = _a.sent();
+                        return [4 /*yield*/, metaResponse.json()];
+                    case 3:
+                        meta = _a.sent();
+                        meta.studio_workflows = meta.studio_workflows.map(function (workflow) {
+                            return __assign(__assign({}, workflow), { handler: parseFunction(workflow.handler) });
+                        });
+                        return [2 /*return*/, meta];
+                }
+            });
+        });
+    };
+    // CRUD methods
+    Lobb.prototype.findAll = function (collectionName, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName, "/search"), {
+                            method: "POST",
+                            headers: this.headers,
+                            body: JSON.stringify(params),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.findOne = function (collectionName, id, queryParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParams = queryParams ? "?".concat(qs.stringify(queryParams)) : "";
+                        return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName, "/").concat(id).concat(queryParams), {
+                                method: "GET",
+                                headers: this.headers,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.createOne = function (collectionName, body, file) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formData_1, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (file) {
+                            formData_1 = new FormData();
+                            Object.keys(body).forEach(function (key) {
+                                formData_1.append(key, body[key]);
+                            });
+                            formData_1.append("file", file, file.name);
+                            formData_1.append("payload", JSON.stringify({
+                                data: body,
+                            }));
+                            body = formData_1;
+                        }
+                        else {
+                            body = JSON.stringify({
+                                data: body,
+                            });
+                        }
+                        return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName), {
+                                method: "POST",
+                                headers: this.headers,
+                                body: body,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.updateOne = function (collectionName, id, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName, "/").concat(id), {
+                            method: "PATCH",
+                            headers: this.headers,
+                            body: JSON.stringify({
+                                data: body,
+                            }),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.readSingleton = function (collectionName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName, "/singleton"), {
+                            method: "GET",
+                            headers: this.headers,
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.updateSingleton = function (collectionName, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName, "/singleton"), {
+                            method: "PATCH",
+                            headers: this.headers,
+                            body: JSON.stringify({
+                                data: body,
+                            }),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.deleteOne = function (collectionName_1, id_1) {
+        return __awaiter(this, arguments, void 0, function (collectionName, id, force) {
+            var response;
+            if (force === void 0) { force = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName, "/").concat(id).concat(force ? "?force" : ""), {
+                            method: "DELETE",
+                            headers: this.headers,
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.deleteMany = function (collectionName_1, filter_1) {
+        return __awaiter(this, arguments, void 0, function (collectionName, filter, force) {
+            var response;
+            if (force === void 0) { force = false; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName).concat(force ? "?force" : ""), {
+                            method: "DELETE",
+                            headers: this.headers,
+                            body: JSON.stringify({
+                                filter: filter,
+                            }),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.createMany = function (collectionName, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        body = JSON.stringify({
+                            data: body,
+                        });
+                        return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName), {
+                                method: "POST",
+                                headers: this.headers,
+                                body: body,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.updateMany = function (collectionName, body, filter) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/").concat(collectionName), {
+                            method: "PATCH",
+                            headers: this.headers,
+                            body: JSON.stringify({
+                                filter: filter,
+                                data: body,
+                            }),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Lobb.prototype.transactions = function (body, rollback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl, "/api/collections/transactions").concat(rollback ? "?rollback" : ""), {
+                            method: "POST",
+                            headers: this.headers,
+                            body: JSON.stringify(body),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // CUSTOM REQUEST methods
+    Lobb.prototype.request = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch("".concat(this.lobbUrl).concat(params.route), {
+                            method: params.method,
+                            headers: this.headers,
+                            body: JSON.stringify(params.payload),
+                        })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, this.handleResponse(response)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // HELPER methods
+    Lobb.prototype.handleResponse = function (response) {
+        return __awaiter(this, void 0, Promise, function () {
+            var index, handler;
+            return __generator(this, function (_a) {
+                for (index = 0; index < this.onResponseHandlers.length; index++) {
+                    handler = this.onResponseHandlers[index];
+                    handler(response.clone());
+                }
+                return [2 /*return*/, response];
+            });
+        });
+    };
+    return Lobb;
+}());
+export { Lobb };

package/dist/Studio.svelte

@@ -0,0 +1,150 @@
+<script lang="ts">
+    import { Toaster } from "./components/ui/sonner";
+    import { onMount, onDestroy } from "svelte";
+    import { ModeWatcher } from "mode-watcher";
+    import { ctx } from "./store.svelte";
+    import { lobb } from "./";
+    import Header from "./components/header.svelte";
+    import { LoaderCircle, ServerOff } from "lucide-svelte";
+    import Dialog from "./components/confirmationDialog/confirmationDialog.svelte";
+    import MiniSidebar from "./components/miniSidebar.svelte";
+    import SetServerPage from "./components/setServerPage.svelte";
+    import * as Tooltip from "./components/ui/tooltip";
+    import { Router, Route, Fallback, init as initRouter,  } from "@wjfe/n-savant";
+    import {
+        executeExtensionsOnStartup,
+        loadExtensions,
+    } from "./extensions/extensionUtils";
+    import { mediaQueries } from "./utils";
+    import Home from "../../routes/home.svelte";
+    import DataModel from "../../routes/data_model/dataModel.svelte";
+    import Collections from "../../routes/collections/collections.svelte";
+    import Workflows from "../../routes/workflows/workflows.svelte";
+    import Extension from "../../routes/extensions/extension.svelte";
+
+    interface StudioProps {
+      extensions?: any[];
+    }
+
+    const props: StudioProps = $props()
+
+    let error: string | null = $state(null);
+    let loaded = $state(false);
+    let isSmallScreen = $derived(!mediaQueries.sm.current);
+    let cleanupRouter: (() => void) | undefined;
+
+    onMount(async () => {
+        cleanupRouter = initRouter();
+
+        if (ctx.lobbUrl) {
+            try {
+                ctx.meta = await lobb.getMeta();
+                ctx.extensions = await loadExtensions(props.extensions);
+                await executeExtensionsOnStartup();
+            } catch (err) {
+                console.error(err);
+                error = "CANT_CONNECT";
+            }
+        }
+        loaded = true;
+    });
+
+    onDestroy(() => {
+        if (cleanupRouter) {
+            cleanupRouter();
+        }
+    });
+</script>
+
+<ModeWatcher defaultMode="light" />
+<Toaster position="top-right" class="z-50" />
+{#if loaded}
+    {#if ctx.lobbUrl}
+        <Tooltip.Provider delayDuration={0} disableHoverableContent={true}>
+            <main
+                class="bg-muted h-screen w-screen"
+                style="display: grid; grid-template-columns: {isSmallScreen
+                    ? '1fr'
+                    : '3.5rem 1fr'};"
+            >
+                <MiniSidebar />
+                <div class="second_grid">
+                    <Header />
+                    <Router id="root-router">
+                        <Route key="home" path="/">
+                            {#snippet children(params)}
+                                <Home />
+                            {/snippet}
+                        </Route>
+                        <Route
+                            key="collections"
+                            path="/collections/:collection?"
+                        >
+                            {#snippet children(params)}
+                                <Collections
+                                    collectionName={params?.collection}
+                                />
+                            {/snippet}
+                        </Route>
+                        <Route key="datamodel" path="/datamodel/*">
+                            {#snippet children(params)}
+                                <DataModel />
+                            {/snippet}
+                        </Route>
+                        <Route key="workflows" path="/workflows/:workflow?">
+                            {#snippet children(params)}
+                                <Workflows workflowName={params?.workflow} />
+                            {/snippet}
+                        </Route>
+                        <Route
+                            key="extensions"
+                            path="/extensions/:extension?/:page?/*"
+                        >
+                            {#snippet children(params)}
+                                <Extension
+                                    extension={params?.extension}
+                                    page={params?.page}
+                                />
+                            {/snippet}
+                        </Route>
+                        <Fallback>Not Found</Fallback>
+                    </Router>
+                </div>
+            </main>
+        </Tooltip.Provider>
+    {:else}
+        <SetServerPage />
+    {/if}
+{:else if !error}
+    <div
+        class="flex h-screen w-full flex-col items-center justify-center gap-4 text-muted-foreground"
+    >
+        <LoaderCircle class="animate-spin opacity-50" size="50" />
+        <div class="flex flex-col items-center justify-center">
+            <div>Loading the dashboard, please wait...</div>
+            <div class="text-xs">
+                Loading and importing all necessary data and components from the
+                lobb server.
+            </div>
+        </div>
+    </div>
+{:else}
+    <div
+        class="flex h-full w-full flex-col items-center justify-center gap-4 text-muted-foreground"
+    >
+        <ServerOff class="opacity-50" size="50" />
+        <div class="flex flex-col items-center justify-center">
+            <div>Could not connect to the server</div>
+            <div class="text-xs">
+                Could not connect to the lobb server at this endpoint ({ctx.lobbUrl})
+            </div>
+        </div>
+    </div>
+{/if}
+
+<style>
+    .second_grid {
+        display: grid;
+        grid-template-rows: 2.5rem 1fr;
+    }
+</style>

package/dist/Studio.svelte.d.ts

@@ -0,0 +1,6 @@
+interface StudioProps {
+    extensions?: any[];
+}
+declare const Studio: import("svelte").Component<StudioProps, {}, "">;
+type Studio = ReturnType<typeof Studio>;
+export default Studio;

package/{src/lib → dist}/components/LlmButton.svelte

@@ -1,11 +1,11 @@
 <script lang="ts">
-	import { lobb } from "$lib";
+	import { lobb } from "..";
 	import { Brain, LoaderIcon, Send } from "lucide-svelte";
 	import Button, { type ButtonProps } from "./ui/button/button.svelte";
 	import * as Popover from "./ui/popover";
 	import Textarea from "./ui/textarea/textarea.svelte";
 	import { toast } from "svelte-sonner";
-	import { ctx } from "$lib/store.svelte";
+	import { ctx } from "../store.svelte";
 
 	interface LocalProp {
 		value?: any;

package/dist/components/LlmButton.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type ButtonProps } from "./ui/button/button.svelte";
+interface LocalProp {
+    value?: any;
+    title: string;
+    description?: string;
+    placeholder?: string;
+    format?: any;
+    messages?: any[];
+    variant?: ButtonProps["variant"];
+    class?: ButtonProps["class"];
+    Icon?: ButtonProps["Icon"];
+    children?: ButtonProps["children"];
+    onApiResponseComplete?: (res: any) => Promise<void>;
+}
+declare const LlmButton: import("svelte").Component<LocalProp, {}, "value">;
+type LlmButton = ReturnType<typeof LlmButton>;
+export default LlmButton;

package/{src/lib → dist}/components/Studio.svelte

@@ -1,21 +1,21 @@
 <script lang="ts">
-    import { Toaster } from "$lib/components/ui/sonner";
+    import { Toaster } from "./ui/sonner";
     import { onMount, onDestroy } from "svelte";
     import { ModeWatcher } from "mode-watcher";
-    import { ctx } from "$lib/store.svelte";
-    import { lobb } from "$lib";
-    import Header from "$lib/components/header.svelte";
+    import { ctx } from "../store.svelte";
+    import { lobb } from "..";
+    import Header from "./header.svelte";
     import { LoaderCircle, ServerOff } from "lucide-svelte";
-    import Dialog from "$lib/components/confirmationDialog/confirmationDialog.svelte";
-    import MiniSidebar from "$lib/components/miniSidebar.svelte";
-    import SetServerPage from "$lib/components/setServerPage.svelte";
-    import * as Tooltip from "$lib/components/ui/tooltip";
+    import Dialog from "./confirmationDialog/confirmationDialog.svelte";
+    import MiniSidebar from "./miniSidebar.svelte";
+    import SetServerPage from "./setServerPage.svelte";
+    import * as Tooltip from "./ui/tooltip";
     import { Router, Route, Fallback, init as initRouter,  } from "@wjfe/n-savant";
     import {
         executeExtensionsOnStartup,
         loadExtensions,
-    } from "$lib/extensions/extensionUtils";
-    import { mediaQueries } from "$lib/utils";
+    } from "../extensions/extensionUtils";
+    import { mediaQueries } from "../utils";
     import Home from "./routes/home.svelte";
     import DataModel from "./routes/data_model/dataModel.svelte";
     import Collections from "./routes/collections/collections.svelte";

package/dist/components/Studio.svelte.d.ts

@@ -0,0 +1,6 @@
+interface StudioProps {
+    extensions?: any[];
+}
+declare const Studio: import("svelte").Component<StudioProps, {}, "">;
+type Studio = ReturnType<typeof Studio>;
+export default Studio;

package/{src/lib → dist}/components/alertView.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import * as Alert from "$lib/components/ui/alert/index.js";
+  import * as Alert from "./ui/alert/index.js";
   import { AlertCircleIcon } from "lucide-svelte";
   import type { Snippet } from "svelte";
 

package/dist/components/alertView.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from "svelte";
+interface Props {
+    title: string;
+    children: Snippet<[]>;
+}
+declare const AlertView: import("svelte").Component<Props, {}, "">;
+type AlertView = ReturnType<typeof AlertView>;
+export default AlertView;

package/{src/lib → dist}/components/breadCrumbs.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import * as Breadcrumb from "./ui/breadcrumb";
-	import { ctx } from "$lib/store.svelte";
-	import { mediaQueries } from "$lib/utils";
+	import { ctx } from "../store.svelte";
+	import { mediaQueries } from "../utils";
 	import { location } from "@wjfe/n-savant";
 
 	const isSmall = $derived(!mediaQueries.sm.current);

package/dist/components/breadCrumbs.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const BreadCrumbs: import("svelte").Component<Record<string, never>, {}, "">;
+type BreadCrumbs = ReturnType<typeof BreadCrumbs>;
+export default BreadCrumbs;

package/{src/lib → dist}/components/combobox.svelte

@@ -2,10 +2,10 @@
     import CheckIcon from "@lucide/svelte/icons/check";
     import ChevronsUpDownIcon from "@lucide/svelte/icons/chevrons-up-down";
     import { tick } from "svelte";
-    import * as Command from "$lib/components/ui/command/index.js";
-    import * as Popover from "$lib/components/ui/popover/index.js";
-    import { Button } from "$lib/components/ui/button/index.js";
-    import { cn } from "$lib/utils.js";
+    import * as Command from "./ui/command/index.js";
+    import * as Popover from "./ui/popover/index.js";
+    import { Button } from "./ui/button/index.js";
+    import { cn } from "../utils.js";
     import type { HTMLButtonAttributes } from "svelte/elements";
 
     interface Option {

package/dist/components/combobox.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLButtonAttributes } from "svelte/elements";
+interface Option {
+    value: string;
+    label: string;
+}
+interface Props {
+    placeholder: string;
+    searchPlaceholder: string;
+    options: Option[];
+    value: string;
+    buttonClass?: HTMLButtonAttributes["class"];
+}
+declare const Combobox: import("svelte").Component<Props, {}, "value">;
+type Combobox = ReturnType<typeof Combobox>;
+export default Combobox;

package/{src/lib → dist}/components/confirmationDialog/confirmationDialog.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import * as AlertDialog from "$lib/components/ui/alert-dialog/index";
+	import * as AlertDialog from "../ui/alert-dialog/index";
 	import { Check, X } from "lucide-svelte";
 	import Button from "../ui/button/button.svelte";