@lobb-js/studio 0.1.31 → 0.1.32

package/dist/detailView/utils.js

@@ -0,0 +1,165 @@
+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);
+};
+import Mustache from "mustache";
+import { ctx } from "../../store.svelte";
+import { getFieldRelation } from "../../utils";
+import { getField } from "../dataTable/utils";
+export function getDefaultEntry(fieldNames, collectionName, values) {
+    return Object.fromEntries(fieldNames.map(function (fieldName) {
+        var _a;
+        var value = null;
+        var field = getField(fieldName, collectionName);
+        if (values && values[fieldName] !== undefined) {
+            value = values[fieldName];
+        }
+        else if ((_a = field.pre_processors) === null || _a === void 0 ? void 0 : _a.default) {
+            var defualtValue = field.pre_processors.default;
+            if (typeof defualtValue === "string") {
+                value = Mustache.render(defualtValue, {
+                    now: new Date().toISOString(),
+                });
+            }
+            else {
+                value = defualtValue;
+            }
+        }
+        return [fieldName, value];
+    }));
+}
+export function serializeEntry(collectionName, entry, rollback) {
+    if (rollback === void 0) { rollback = false; }
+    // deep clone the object
+    entry = __assign({}, entry);
+    // serialize the foreign key field's value
+    for (var _i = 0, _a = Object.entries(entry); _i < _a.length; _i++) {
+        var _b = _a[_i], fieldName = _b[0], fieldValue = _b[1];
+        var isRefrenceField = Boolean(getFieldRelation(collectionName, fieldName));
+        if (isRefrenceField && fieldValue !== null && fieldValue.id !== undefined) {
+            entry[fieldName] = fieldValue.id;
+        }
+    }
+    // check for related collections properties and serialize them too
+    if (!rollback) {
+        var childrenRelations = ctx.meta.relations.filter(function (relation) { return relation.to.collection === collectionName; });
+        var childrenCollectionNames = childrenRelations.map(function (relation) { return relation.from.collection; });
+        for (var index = 0; index < childrenCollectionNames.length; index++) {
+            var childrenCollectionName = childrenCollectionNames[index];
+            var childrenEntries = entry[childrenCollectionName];
+            if (childrenEntries) {
+                for (var index_1 = 0; index_1 < childrenEntries.length; index_1++) {
+                    childrenEntries[index_1] = serializeEntry(childrenCollectionName, childrenEntries[index_1]);
+                }
+            }
+        }
+    }
+    return entry;
+}
+export function generateTransactionBody(collectionName, entry) {
+    entry = __assign({}, entry);
+    function handleEntryRecursive(transactionBody, collectionName, entry, parentTransactionIndex) {
+        var _a;
+        var _b;
+        var parentCollectionName = parentTransactionIndex !== undefined ? transactionBody[parentTransactionIndex].collection : null;
+        var foreignKeyFieldName = (_b = ctx.meta.relations.find(function (relation) { return relation.from.collection === collectionName && relation.to.collection === parentCollectionName; })) === null || _b === void 0 ? void 0 : _b.from.field;
+        var collectionFieldNames = Object.keys(ctx.meta.collections[collectionName].fields);
+        var payload = {};
+        for (var index = 0; index < collectionFieldNames.length; index++) {
+            var fieldName = collectionFieldNames[index];
+            var isForeignKeyField = fieldName === foreignKeyFieldName;
+            if (isForeignKeyField) {
+                payload[fieldName] = "{{ responses[".concat(parentTransactionIndex, "].data.id }}");
+                continue;
+            }
+            payload[fieldName] = entry[fieldName];
+        }
+        var localTransactionIndex = transactionBody.length;
+        if (payload.id) {
+            var localPayload = (_a = {},
+                _a[foreignKeyFieldName] = payload[foreignKeyFieldName],
+                _a);
+            transactionBody.push({
+                collection: collectionName,
+                method: "updateMany",
+                args: [
+                    localPayload,
+                    {
+                        id: payload.id
+                    }
+                ],
+            });
+        }
+        else {
+            transactionBody.push({
+                collection: collectionName,
+                method: "createOne",
+                args: [payload],
+            });
+        }
+        var childrenRelations = ctx.meta.relations.filter(function (relation) { return relation.to.collection === collectionName; });
+        var childrenCollectionNames = childrenRelations.map(function (relation) { return relation.from.collection; });
+        for (var index = 0; index < childrenCollectionNames.length; index++) {
+            var childrenCollectionName = childrenCollectionNames[index];
+            var childrenEntries = entry[childrenCollectionName];
+            if (childrenEntries) {
+                for (var index_2 = 0; index_2 < childrenEntries.length; index_2++) {
+                    var childrenEntry = childrenEntries[index_2];
+                    handleEntryRecursive(transactionBody, childrenCollectionName, childrenEntry, localTransactionIndex);
+                }
+            }
+        }
+    }
+    var transactionBody = [];
+    handleEntryRecursive(transactionBody, collectionName, entry);
+    return transactionBody;
+}
+export function parseDetailViewValues(collectionName, values) {
+    var forignFieldNames = ctx.meta.relations
+        .filter(function (relation) { return relation.from.collection === collectionName; })
+        .map(function (relation) { return relation.from.field; });
+    var childCollectionNames = ctx.meta.relations
+        .filter(function (relation) { return relation.to.collection === collectionName; })
+        .map(function (relation) { return relation.from.collection; });
+    for (var _i = 0, _a = Object.entries(values); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        if (forignFieldNames.includes(key)) {
+            if (typeof value === 'number') {
+                values[key] = {
+                    id: value,
+                };
+            }
+        }
+        else if (childCollectionNames.includes(key)) {
+            for (var index = 0; index < values[key].length; index++) {
+                parseDetailViewValues(key, values[key][index]);
+            }
+        }
+    }
+}
+export function getCollectionFields(collectionName) {
+    var returnedData = [];
+    var collectionFields = ctx.meta.collections[collectionName].fields;
+    var isSingleton = ctx.meta.collections[collectionName].singleton;
+    for (var _i = 0, _a = Object.entries(collectionFields); _i < _a.length; _i++) {
+        var _b = _a[_i], fieldName = _b[0], value = _b[1];
+        if (isSingleton && fieldName === "id") {
+            continue;
+        }
+        returnedData.push({
+            type: "input",
+            key: fieldName,
+            label: fieldName,
+            disabled: fieldName == "id",
+            placeholder: fieldName == "id" ? "AUTO_GENERATED" : "",
+        });
+    }
+    return returnedData;
+}

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

@@ -6,7 +6,7 @@
 	import cssWorker from "monaco-editor/esm/vs/language/css/css.worker?worker";
 	import htmlWorker from "monaco-editor/esm/vs/language/html/html.worker?worker";
 	import tsWorker from "monaco-editor/esm/vs/language/typescript/ts.worker?worker";
-	import { cn } from "$lib/utils";
+	import { cn } from "../utils";
 
 	interface Props {
 		type: "javascript" | "typescript" | "json";

package/dist/diffViewer.svelte.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    type: "javascript" | "typescript" | "json";
+    original: string;
+    modified: string;
+    class?: string;
+}
+declare const DiffViewer: import("svelte").Component<Props, {}, "">;
+type DiffViewer = ReturnType<typeof DiffViewer>;
+export default DiffViewer;

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

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { calculateDrawerWidth } from "$lib/utils";
+    import { calculateDrawerWidth } from "../utils";
     import type { Snippet } from "svelte";
     import { fade, fly } from "svelte/transition";
 

package/dist/drawer.svelte.d.ts

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

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

@@ -1,6 +1,6 @@
 <script lang="ts">
     import type { Snippet } from "svelte";
-	import { loadExtensionComponents } from "../../extensions/extensionUtils";
+	import { loadExtensionComponents } from "../extensions/extensionUtils";
 
 	interface Props {
 		name: string;
@@ -28,4 +28,3 @@
 {:else}
 	{@render children?.()}
 {/if}
-	

package/dist/extensionsComponents.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from "svelte";
+interface Props {
+    name: string;
+    filterByExtensions?: string[];
+    value?: unknown;
+    children?: Snippet<[]>;
+    [key: string]: any;
+}
+declare const ExtensionsComponents: import("svelte").Component<Props, {}, "value">;
+type ExtensionsComponents = ReturnType<typeof ExtensionsComponents>;
+export default ExtensionsComponents;

package/dist/foreingKeyInput.svelte.d.ts

@@ -0,0 +1,11 @@
+interface LocalProps {
+    parentCollectionName: string;
+    collectionName: string;
+    fieldName: string;
+    value?: any;
+    destructive?: boolean;
+    entry: Record<string, any>;
+}
+declare const ForeingKeyInput: import("svelte").Component<LocalProps, {}, "value">;
+type ForeingKeyInput = ReturnType<typeof ForeingKeyInput>;
+export default ForeingKeyInput;

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

@@ -4,7 +4,7 @@
 	import { Menu, Moon, Sun } from "lucide-svelte";
 	import BreadCrumbs from "./breadCrumbs.svelte";
 	import { toggleMode, mode } from "mode-watcher";
-	import { mediaQueries } from "$lib/utils";
+	import { mediaQueries } from "../utils";
 	import { expandMiniSideBar } from "./miniSidebar.svelte";
 
 	let isSmallScreen = $derived(!mediaQueries.sm.current);

package/dist/header.svelte.d.ts

@@ -0,0 +1,6 @@
+export default Header;
+type Header = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<Record<string, never>>): void;
+};
+declare const Header: import("svelte").Component<Record<string, never>, {}, "">;

package/dist/loadingTypesForMonacoEditor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TODO
+ *
+ * this file shows an example of downloading the types files of a library from npm to use them in adding type support of that library in the vscode editor
+ * so the whole point is that for users to be able to paste a url from npm or jsr of a library and have all ts support from its types
+ */
+export {};

package/dist/loadingTypesForMonacoEditor.js

@@ -0,0 +1,72 @@
+/**
+ * TODO
+ *
+ * this file shows an example of downloading the types files of a library from npm to use them in adding type support of that library in the vscode editor
+ * so the whole point is that for users to be able to paste a url from npm or jsr of a library and have all ts support from its types
+ */
+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 { gunzipSync } from "fflate";
+import { untar } from "@andrewbranch/untar.js";
+function extractTgz(buffer) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tarBuffer, cleanBuffer, files, dtsFiles, _i, files_1, file, content;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tarBuffer = gunzipSync(new Uint8Array(buffer));
+                    cleanBuffer = tarBuffer.buffer.slice(tarBuffer.byteOffset, tarBuffer.byteOffset + tarBuffer.byteLength);
+                    return [4 /*yield*/, untar(cleanBuffer)];
+                case 1:
+                    files = _a.sent();
+                    dtsFiles = [];
+                    for (_i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        file = files_1[_i];
+                        if (file.filename.endsWith(".d.ts")) {
+                            content = new TextDecoder().decode(file.fileData);
+                            dtsFiles.push({ name: file.filename, content: content });
+                        }
+                    }
+                    return [2 /*return*/, dtsFiles];
+            }
+        });
+    });
+}
+var tgzURL = "https://registry.npmjs.org/zod/-/zod-3.22.4.tgz";
+var response = await fetch(tgzURL);
+var arrayBuffer = await response.arrayBuffer();
+var files = await extractTgz(arrayBuffer);

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

@@ -12,14 +12,14 @@
 
 <script lang="ts">
 	import { House, Layers, Library, LogOut, Workflow, X } from "lucide-svelte";
-	import Button from "$lib/components/ui/button/button.svelte";
-	import Separator from "$lib/components/ui/separator/separator.svelte";
-	import * as Tooltip from "$lib/components/ui/tooltip";
-	import * as Accordion from "$lib/components/ui/accordion/index.js";
+	import Button from "./ui/button/button.svelte";
+	import Separator from "./ui/separator/separator.svelte";
+	import * as Tooltip from "./ui/tooltip";
+	import * as Accordion from "./ui/accordion/index.js";
 
-	import { ctx } from "$lib/store.svelte";
-	import { getDashboardNavs } from "../../extensions/extensionUtils";
-	import { mediaQueries } from "$lib/utils";
+	import { ctx } from "../store.svelte";
+	import { getDashboardNavs } from "../extensions/extensionUtils";
+	import { mediaQueries } from "../utils";
 	import * as Popover from "./ui/popover";
 	import { location } from "@wjfe/n-savant";
 

package/dist/miniSidebar.svelte.d.ts

@@ -0,0 +1,20 @@
+export declare let collapseMiniSideBar: () => void;
+export declare let expandMiniSideBar: () => void;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MiniSidebar: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MiniSidebar = InstanceType<typeof MiniSidebar>;
+export default MiniSidebar;

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

@@ -6,7 +6,7 @@
 	import cssWorker from "monaco-editor/esm/vs/language/css/css.worker?worker";
 	import htmlWorker from "monaco-editor/esm/vs/language/html/html.worker?worker";
 	import tsWorker from "monaco-editor/esm/vs/language/typescript/ts.worker?worker";
-	import { cn } from "$lib/utils";
+	import { cn } from "../utils";
 
 	interface Props {
 		type: "javascript" | "typescript" | "json" | "sql";

package/dist/monacoEditor.svelte.d.ts

@@ -0,0 +1,13 @@
+interface Props {
+    type: "javascript" | "typescript" | "json" | "sql";
+    name: string;
+    value?: string;
+    default?: string;
+    types?: string;
+    class?: string;
+    handleCtrlSave?: () => void;
+    onChange?: (value: string) => void;
+}
+declare const MonacoEditor: import("svelte").Component<Props, {}, "value">;
+type MonacoEditor = ReturnType<typeof MonacoEditor>;
+export default MonacoEditor;

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

@@ -10,10 +10,10 @@
         startOfWeek,
         today,
     } from "@internationalized/date";
-    import { cn } from "$lib/utils.js";
-    import { buttonVariants } from "$lib/components/ui/button/index.js";
-    import { RangeCalendar } from "$lib/components/ui/range-calendar/index.js";
-    import * as Popover from "$lib/components/ui/popover/index.js";
+    import { cn } from "../utils.js";
+    import { buttonVariants } from "./ui/button/index.js";
+    import { RangeCalendar } from "./ui/range-calendar/index.js";
+    import * as Popover from "./ui/popover/index.js";
     import Input from "./ui/input/input.svelte";
 
     interface Props {

package/dist/rangeCalendarButton.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { DateRange } from "bits-ui";
+interface Props {
+    value: DateRange;
+}
+declare const RangeCalendarButton: import("svelte").Component<Props, {}, "value">;
+type RangeCalendarButton = ReturnType<typeof RangeCalendarButton>;
+export default RangeCalendarButton;

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

@@ -3,7 +3,7 @@
 	import Button, { type ButtonProps } from "./ui/button/button.svelte";
 	import DataTable from "./dataTable/dataTable.svelte";
 	import { getCollectionPrimaryField } from "./dataTable/utils";
-	import { emitEvent } from "$lib/eventSystem";
+	import { emitEvent } from "../eventSystem";
   import Drawer from "./drawer.svelte";
 
 	interface LocalProps extends ButtonProps {

package/dist/selectRecord.svelte.d.ts

@@ -0,0 +1,15 @@
+import { type ButtonProps } from "./ui/button/button.svelte";
+interface LocalProps extends ButtonProps {
+    collectionName: string;
+    parentCollectionName?: string;
+    fieldName?: string;
+    value?: any;
+    onSelect?: (entry: any) => void;
+    filter?: Record<string, any>;
+    additionalFilter?: Record<string, any>;
+    text?: string;
+    entry?: Record<string, any>;
+}
+declare const SelectRecord: import("svelte").Component<LocalProps, {}, "value">;
+type SelectRecord = ReturnType<typeof SelectRecord>;
+export default SelectRecord;

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

@@ -1,8 +1,8 @@
 <script lang="ts">
 	import { toast } from "svelte-sonner";
 	import Button from "./ui/button/button.svelte";
-	import { ctx } from "$lib/store.svelte";
-	import { Input } from "$lib/components/ui/input";
+	import { ctx } from "../store.svelte";
+	import { Input } from "./ui/input";
 
 	let formData = {
 		server: "",

package/dist/setServerPage.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const SetServerPage: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type SetServerPage = InstanceType<typeof SetServerPage>;
+export default SetServerPage;

package/{src/lib/components/sidebar/index.ts → dist/sidebar/index.d.ts}

@@ -1,4 +1,3 @@
 import Sidebar from "./sidebar.svelte";
 import SidebarTrigger from "./sidebarTrigger.svelte";
-
-export { Sidebar, SidebarTrigger }
+export { Sidebar, SidebarTrigger };

package/dist/sidebar/index.js

@@ -0,0 +1,3 @@
+import Sidebar from "./sidebar.svelte";
+import SidebarTrigger from "./sidebarTrigger.svelte";
+export { Sidebar, SidebarTrigger };

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

@@ -7,7 +7,7 @@
 <script lang="ts">
     import { setContext, type Snippet } from "svelte";
 
-    import { mediaQueries } from "$lib/utils";
+    import { mediaQueries } from "../../utils";
     import Skeleton from "../ui/skeleton/skeleton.svelte";
     import { Search } from "lucide-svelte";
     import SidebarElements, {

package/dist/sidebar/sidebar.svelte.d.ts

@@ -0,0 +1,17 @@
+export interface SidebarProperties {
+    collapsed: boolean;
+}
+import { type Snippet } from "svelte";
+import { type SideBarData, type SideBarElement, type SidebarElementsProps } from "./sidebarElements.svelte";
+interface Props {
+    title: string;
+    data: SideBarData | null;
+    sidebarElementsProps?: Partial<SidebarElementsProps>;
+    showSearch?: boolean;
+    children: Snippet<[]>;
+    belowSearch?: Snippet;
+    elementRightSide?: Snippet<[SideBarElement]>;
+}
+declare const Sidebar: import("svelte").Component<Props, {}, "">;
+type Sidebar = ReturnType<typeof Sidebar>;
+export default Sidebar;

package/dist/sidebar/sidebarElements.svelte.d.ts

@@ -0,0 +1,19 @@
+export interface SideBarElement {
+    name: string;
+    onclick?: () => Promise<void> | void;
+    href?: string;
+    icon?: any;
+    path?: string;
+    meta?: Record<string, any>;
+}
+export type SideBarData = Array<SideBarElement>;
+export interface SidebarElementsProps {
+    data: SideBarData;
+    path?: string[];
+    elementRightSide?: Snippet<[SideBarElement]>;
+}
+import type { Snippet } from "svelte";
+import SidebarElements from "./sidebarElements.svelte";
+declare const SidebarElements: import("svelte").Component<SidebarElementsProps, {}, "data">;
+type SidebarElements = ReturnType<typeof SidebarElements>;
+export default SidebarElements;

package/dist/sidebar/sidebarTrigger.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { HTMLButtonAttributes } from "svelte/elements";
+interface Props {
+    class?: HTMLButtonAttributes["class"];
+}
+declare const SidebarTrigger: import("svelte").Component<Props, {}, "">;
+type SidebarTrigger = ReturnType<typeof SidebarTrigger>;
+export default SidebarTrigger;

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

@@ -5,7 +5,7 @@
     import SidebarTrigger from "./sidebar/sidebarTrigger.svelte";
     import Button from "./ui/button/button.svelte";
     import { onMount } from "svelte";
-    import { lobb } from "$lib";
+    import { lobb } from "..";
   import { toast } from "svelte-sonner";
   import Skeleton from "./ui/skeleton/skeleton.svelte";
 

package/dist/singletone.svelte.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    collectionName: string;
+}
+declare const Singletone: import("svelte").Component<Props, {}, "">;
+type Singletone = ReturnType<typeof Singletone>;
+export default Singletone;

package/{src/lib/components → dist}/ui/accordion/accordion-content.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { Accordion as AccordionPrimitive, type WithoutChild } from "bits-ui";
-	import { cn } from "$lib/utils.js";
+	import { cn } from "../../../utils.js";
 
 	let {
 		ref = $bindable(null),

package/dist/ui/accordion/accordion-content.svelte.d.ts

@@ -0,0 +1,4 @@
+import { Accordion as AccordionPrimitive } from "bits-ui";
+declare const AccordionContent: import("svelte").Component<Omit<AccordionPrimitive.ContentProps, "child">, {}, "ref">;
+type AccordionContent = ReturnType<typeof AccordionContent>;
+export default AccordionContent;

package/{src/lib/components → dist}/ui/accordion/accordion-item.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { Accordion as AccordionPrimitive } from "bits-ui";
-	import { cn } from "$lib/utils.js";
+	import { cn } from "../../../utils.js";
 
 	let {
 		ref = $bindable(null),

package/dist/ui/accordion/accordion-item.svelte.d.ts

@@ -0,0 +1,4 @@
+import { Accordion as AccordionPrimitive } from "bits-ui";
+declare const AccordionItem: import("svelte").Component<AccordionPrimitive.ItemProps, {}, "ref">;
+type AccordionItem = ReturnType<typeof AccordionItem>;
+export default AccordionItem;

package/{src/lib/components → dist}/ui/accordion/accordion-trigger.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { Accordion as AccordionPrimitive, type WithoutChild } from "bits-ui";
 	import ChevronDown from "@lucide/svelte/icons/chevron-down";
-	import { cn } from "$lib/utils.js";
+	import { cn } from "../../../utils.js";
 
 	let {
 		ref = $bindable(null),

package/dist/ui/accordion/accordion-trigger.svelte.d.ts

@@ -0,0 +1,7 @@
+import { Accordion as AccordionPrimitive, type WithoutChild } from "bits-ui";
+type $$ComponentProps = WithoutChild<AccordionPrimitive.TriggerProps> & {
+    level?: AccordionPrimitive.HeaderProps["level"];
+};
+declare const AccordionTrigger: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type AccordionTrigger = ReturnType<typeof AccordionTrigger>;
+export default AccordionTrigger;

package/dist/ui/accordion/index.d.ts

@@ -0,0 +1,6 @@
+import { Accordion as AccordionPrimitive } from "bits-ui";
+import Content from "./accordion-content.svelte";
+import Item from "./accordion-item.svelte";
+import Trigger from "./accordion-trigger.svelte";
+declare const Root: import("svelte").Component<AccordionPrimitive.RootProps, {}, "value" | "ref">;
+export { Root, Content, Item, Trigger, Root as Accordion, Content as AccordionContent, Item as AccordionItem, Trigger as AccordionTrigger, };