@lobb-js/studio 0.1.38 → 0.1.39

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

@@ -0,0 +1,8 @@
+interface DialogProps {
+    title: string;
+    description: string;
+    onDecision: (result: boolean) => void;
+}
+declare const ConfirmationDialog: import("svelte").Component<DialogProps, {}, "">;
+type ConfirmationDialog = ReturnType<typeof ConfirmationDialog>;
+export default ConfirmationDialog;

package/dist/components/confirmationDialog/store.svelte.d.ts

@@ -0,0 +1 @@
+export declare function showDialog(title: string, description: string): Promise<boolean>;

package/dist/components/confirmationDialog/store.svelte.js

@@ -0,0 +1,69 @@
+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 { mount, unmount } from "svelte";
+import ConfirmationDialog from "./confirmationDialog.svelte";
+export function showDialog(title, description) {
+    var _this = this;
+    return new Promise(function (resolve) {
+        var targetElement = document.querySelector('main');
+        if (!targetElement) {
+            throw new Error("main html element doesn't exist for some reason");
+        }
+        var mountedElement = mount(ConfirmationDialog, {
+            target: targetElement,
+            props: {
+                title: title,
+                description: description,
+                onDecision: function (result) { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                resolve(result);
+                                return [4 /*yield*/, unmount(mountedElement, {
+                                        outro: true
+                                    })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }
+            },
+        });
+        console.log("the dialog is mounted man");
+    });
+}

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

@@ -4,8 +4,8 @@
 	import Button, { type ButtonProps } from "./ui/button/button.svelte";
 	import { toast } from "svelte-sonner";
 	import MonacoEditor from "./monacoEditor.svelte";
-	import { lobb } from "$lib";
-	import { calculateDrawerWidth } from "$lib/utils";
+	import { lobb } from "..";
+	import { calculateDrawerWidth } from "../utils";
   import Drawer from "./drawer.svelte";
 
 	interface LocalProps extends ButtonProps {

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

@@ -0,0 +1,8 @@
+import { type ButtonProps } from "./ui/button/button.svelte";
+interface LocalProps extends ButtonProps {
+    collectionName: string;
+    onSuccessfullSave?: () => Promise<void>;
+}
+declare const CreateManyButton: import("svelte").Component<LocalProps, {}, "">;
+type CreateManyButton = ReturnType<typeof CreateManyButton>;
+export default CreateManyButton;

package/{src/lib → dist}/components/dataTable/childRecords.svelte

@@ -1,10 +1,10 @@
 <script lang="ts">
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import { ChevronRight, Plus, Smartphone, Table } from "lucide-svelte";
     import DataTable from "./dataTable.svelte";
     import CreateDetailViewButton from "../detailView/create/createDetailViewButton.svelte";
     import ExtensionsComponents from "../extensionsComponents.svelte";
-    import { getExtensionUtils } from "$lib/extensions/extensionUtils";
+    import { getExtensionUtils } from "../../extensions/extensionUtils";
 
     interface Props {
         collectionName: string;

package/dist/components/dataTable/childRecords.svelte.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    collectionName: string;
+    recordId: string;
+    width: number;
+    unifiedBgColor?: "bg-soft" | "bg-background";
+}
+declare const ChildRecords: import("svelte").Component<Props, {}, "">;
+type ChildRecords = ReturnType<typeof ChildRecords>;
+export default ChildRecords;

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

@@ -1,6 +1,6 @@
 <script lang="ts">
     import _ from "lodash";
-    import { lobb } from "$lib";
+    import { lobb } from "../..";
     import Footer from "./footer.svelte";
     import Header from "./header.svelte";
     import Table, { type TableProps } from "./table.svelte";
@@ -10,11 +10,11 @@
     import ChildRecords from "./childRecords.svelte";
     import FieldCell from "./fieldCell.svelte";
     import Skeleton from "../ui/skeleton/skeleton.svelte";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import Button from "../ui/button/button.svelte";
     import { showDialog } from "../confirmationDialog/store.svelte";
     import UpdateDetailViewButton from "../detailView/update/updateDetailViewButton.svelte";
-    import { emitEvent } from "$lib/eventSystem";
+    import { emitEvent } from "../../eventSystem";
     import type { Snippet } from "svelte";
 
     interface Props {

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

@@ -0,0 +1,15 @@
+import { type TableProps } from "./table.svelte";
+import type { Snippet } from "svelte";
+interface Props {
+    collectionName: string;
+    filter?: any;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    unifiedBgColor?: "bg-soft" | "bg-background";
+    showDelete?: boolean;
+    tableProps?: Partial<TableProps>;
+    headerLeft?: Snippet<[]>;
+}
+declare const DataTable: import("svelte").Component<Props, {}, "">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/{src/lib → dist}/components/dataTable/fieldCell.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { getFieldRelation } from "$lib/utils";
+    import { getFieldRelation } from "../../utils";
     import { ExternalLink } from "lucide-svelte";
     import UpdateDetailViewButton from "../detailView/update/updateDetailViewButton.svelte";
     import { getField } from "./utils";

package/dist/components/dataTable/fieldCell.svelte.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    collectionName: string;
+    fieldName: string;
+    value: any;
+    entry: Record<string, any>;
+    tableParams?: any;
+}
+declare const FieldCell: import("svelte").Component<Props, {}, "tableParams">;
+type FieldCell = ReturnType<typeof FieldCell>;
+export default FieldCell;

package/{src/lib → dist}/components/dataTable/filter.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import * as Popover from "$lib/components/ui/popover/index.js";
+    import * as Popover from "../ui/popover/index.js";
     import Filter from "./filter.svelte";
     import {
         Plus,
@@ -11,7 +11,7 @@
     } from "lucide-svelte";
     import { buttonVariants } from "../ui/button";
     import _ from "lodash";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import Button from "../ui/button/button.svelte";
 
     interface Props {

package/dist/components/dataTable/filter.svelte.d.ts

@@ -0,0 +1,10 @@
+import Filter from "./filter.svelte";
+interface Props {
+    filter: any;
+    collectionName: string;
+    isFirst?: boolean;
+    deleteFilter?: () => void;
+}
+declare const Filter: import("svelte").Component<Props, {}, "filter">;
+type Filter = ReturnType<typeof Filter>;
+export default Filter;

package/{src/lib → dist}/components/dataTable/filterButton.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import * as Popover from "$lib/components/ui/popover/index.js";
+	import * as Popover from "../ui/popover/index.js";
 	import { ListFilter } from "lucide-svelte";
 	import { buttonVariants } from "../ui/button";
 	import Filter from "./filter.svelte";

package/dist/components/dataTable/filterButton.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    filter: any;
+    collectionName: string;
+    showText?: boolean;
+}
+declare const FilterButton: import("svelte").Component<Props, {}, "filter">;
+type FilterButton = ReturnType<typeof FilterButton>;
+export default FilterButton;

package/dist/components/dataTable/footer.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    limit: string;
+    totalCount: number;
+    currentPage: number;
+}
+declare const Footer: import("svelte").Component<Props, {}, "currentPage" | "limit">;
+type Footer = ReturnType<typeof Footer>;
+export default Footer;

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

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import { ListRestart, Plus, SquareStack, Trash } from "lucide-svelte";
     import LlmButton from "../LlmButton.svelte";
     import FilterButton from "./filterButton.svelte";
@@ -7,7 +7,7 @@
     import Button from "../ui/button/button.svelte";
     import CreateManyButton from "../createManyButton.svelte";
     import { showDialog } from "../confirmationDialog/store.svelte";
-    import { lobb } from "$lib";
+    import { lobb } from "../..";
     import CreateDetailViewButton from "../detailView/create/createDetailViewButton.svelte";
     import type { Snippet } from "svelte";
 

package/dist/components/dataTable/header.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from "svelte";
+interface Props {
+    collectionName: string;
+    params: any;
+    selectedRecords: string[];
+    left?: Snippet<[]>;
+}
+declare const Header: import("svelte").Component<Props, {}, "params" | "selectedRecords">;
+type Header = ReturnType<typeof Header>;
+export default Header;

package/{src/lib → dist}/components/dataTable/sort.svelte

@@ -1,12 +1,12 @@
 <script lang="ts">
     import _ from "lodash";
 
-    import * as Popover from "$lib/components/ui/popover/index.js";
+    import * as Popover from "../ui/popover/index.js";
     import { ArrowDown, ArrowUp, GripVertical, Plus, X } from "lucide-svelte";
     import Button, { buttonVariants } from "../ui/button/button.svelte";
     import Label from "../ui/label/label.svelte";
     import Switch from "../ui/switch/switch.svelte";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import { getFieldIcon } from "./utils";
 
     interface Props {

package/dist/components/dataTable/sort.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    collectionName: string;
+    sort: Record<string, "asc" | "desc">;
+    showText: boolean;
+}
+declare const Sort: import("svelte").Component<Props, {}, "sort">;
+type Sort = ReturnType<typeof Sort>;
+export default Sort;

package/{src/lib → dist}/components/dataTable/sortButton.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
-	import * as Popover from "$lib/components/ui/popover/index.js";
+	import * as Popover from "../ui/popover/index.js";
 	import { ArrowDownWideNarrow } from "lucide-svelte";
-	import { buttonVariants } from "$lib/components/ui/button";
+	import { buttonVariants } from "../ui/button";
 	import Sort from "./sort.svelte";
 
 	interface Props {

package/dist/components/dataTable/sortButton.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    collectionName: string;
+    sort: Record<string, "asc" | "desc">;
+    showText: boolean;
+}
+declare const SortButton: import("svelte").Component<Props, {}, "sort">;
+type SortButton = ReturnType<typeof SortButton>;
+export default SortButton;

package/dist/components/dataTable/table.svelte.d.ts

@@ -0,0 +1,32 @@
+interface Column {
+    id: string;
+    icon?: any;
+    subtext?: any;
+}
+type Entry = Record<string, any>;
+interface Select {
+    onSelect: (entry: any) => void;
+}
+export interface TableProps {
+    data: Entry[];
+    columns?: Column[];
+    showCollapsible?: boolean;
+    sort?: Record<string, "asc" | "desc">;
+    localSorting?: boolean;
+    selectedRecords?: Array<any>;
+    selectByColumn?: string | null;
+    showCheckboxes?: boolean;
+    showLastRowBorder?: boolean;
+    showLastColumnBorder?: boolean;
+    overrideCell?: Snippet<[any, Column, Entry]>;
+    tools?: Snippet<[Entry, number]>;
+    collapsible?: Snippet<[Entry, number]>;
+    parentWidth?: number;
+    unifiedBgColor?: "bg-soft" | "bg-background";
+    select?: Select;
+    tableWidth?: number;
+}
+import type { Snippet } from "svelte";
+declare const Table: import("svelte").Component<TableProps, {}, "sort" | "selectedRecords" | "tableWidth">;
+type Table = ReturnType<typeof Table>;
+export default Table;

package/dist/components/dataTable/utils.d.ts

@@ -0,0 +1,7 @@
+import type { TableProps } from "./table.svelte";
+export declare function getCollectionColumns(collectionName: string): TableProps['columns'];
+export declare function getFieldIcon(fieldName: string, collectionName: string): any;
+export declare function getFields(collectionName: string): Record<string, any>;
+export declare function getField(fieldName: string, collectionName: string): any;
+export declare function getCollectionPrimaryField(collectionName: string): string | undefined;
+export declare function getCollectionParamsFields(collectionName: string, allFields?: boolean): string;

package/dist/components/dataTable/utils.js

@@ -0,0 +1,111 @@
+import { ctx } from "../../store.svelte";
+import { Binary, Braces, Brackets, Calendar, CalendarClock, Clock, Hash, Key, Text, Type, } from "lucide-svelte/icons";
+export function getCollectionColumns(collectionName) {
+    var collectionFields = getFields(collectionName);
+    var headers = [];
+    for (var fieldName in collectionFields) {
+        var field = collectionFields[fieldName];
+        headers.push({
+            id: field.key,
+            subtext: field.type,
+            icon: getFieldIcon(fieldName, collectionName),
+        });
+    }
+    return headers;
+}
+export function getFieldIcon(fieldName, collectionName) {
+    var field = getField(fieldName, collectionName);
+    if (fieldName === "id") {
+        return Key;
+    }
+    else if (field.type === "string") {
+        return Type;
+    }
+    else if (field.type === "text") {
+        return Text;
+    }
+    else if (field.type === "object") {
+        return Braces;
+    }
+    else if (field.type === "array") {
+        return Brackets;
+    }
+    else if (field.type === "bool") {
+        return Binary;
+    }
+    else if (field.type === "integer") {
+        return Hash;
+    }
+    else if (field.type === "long") {
+        return Hash;
+    }
+    else if (field.type === "float") {
+        return Hash;
+    }
+    else if (field.type === "decimal") {
+        return Hash;
+    }
+    else if (field.type === "date") {
+        return Calendar;
+    }
+    else if (field.type === "datetime") {
+        return CalendarClock;
+    }
+    else if (field.type === "time") {
+        return Clock;
+    }
+    throw new Error("(".concat(field.type, ") doesnt have an icon"));
+}
+export function getFields(collectionName) {
+    return ctx.meta.collections[collectionName].fields;
+}
+export function getField(fieldName, collectionName) {
+    return getFields(collectionName)[fieldName];
+}
+export function getCollectionPrimaryField(collectionName) {
+    var collectionFields = ctx.meta.collections[collectionName].fields;
+    var primaryFieldObject = Object.values(collectionFields).find(function (field) { return field.type === "string"; });
+    if (primaryFieldObject &&
+        typeof primaryFieldObject === "object" &&
+        "key" in primaryFieldObject) {
+        var fieldName = primaryFieldObject.key;
+        return fieldName;
+    }
+}
+export function getCollectionParamsFields(collectionName, allFields) {
+    if (allFields === void 0) { allFields = false; }
+    var relations = ctx.meta.relations;
+    var foreignFields = relations
+        .filter(function (relation) {
+        return relation.from.collection === collectionName;
+    })
+        .map(function (relation) {
+        return {
+            field: relation.from.field,
+            collection: relation.to.collection,
+        };
+    });
+    var columns = [];
+    for (var index = 0; index < foreignFields.length; index++) {
+        var foreignField = foreignFields[index];
+        if (!foreignField.collection) {
+            continue;
+        }
+        columns.push("".concat(foreignField.field, ".id"));
+        if (!allFields) {
+            var primaryField = getCollectionPrimaryField(foreignField.collection);
+            if (primaryField) {
+                columns.push("".concat(foreignField.field, ".").concat(primaryField));
+            }
+        }
+        else {
+            var fieldNames = Object.keys(ctx.meta.collections[foreignField.collection].fields);
+            for (var index_1 = 0; index_1 < fieldNames.length; index_1++) {
+                var fieldName = fieldNames[index_1];
+                columns.push("".concat(foreignField.field, ".").concat(fieldName));
+            }
+        }
+    }
+    var foreignColumns = columns.join(",");
+    return "*".concat(foreignColumns ? ",".concat(foreignColumns) : "");
+}

package/{src/lib → dist}/components/detailView/create/children.svelte

@@ -1,9 +1,9 @@
 <script lang="ts">
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../../store.svelte";
     import { Link } from "lucide-svelte";
     import CreateManyView from "./createManyView.svelte";
-    import ExtensionsComponents from "$lib/components/extensionsComponents.svelte";
-    import { getExtensionUtils } from "$lib/extensions/extensionUtils";
+    import ExtensionsComponents from "../../extensionsComponents.svelte";
+    import { getExtensionUtils } from "../../../extensions/extensionUtils";
 
     interface LocalProp {
         collectionName: string;

package/dist/components/detailView/create/children.svelte.d.ts

@@ -0,0 +1,8 @@
+interface LocalProp {
+    collectionName: string;
+    entry: any;
+    values?: Record<string, any>;
+}
+declare const Children: import("svelte").Component<LocalProp, {}, "entry">;
+type Children = ReturnType<typeof Children>;
+export default Children;

package/{src/lib → dist}/components/detailView/create/createDetailView.svelte

@@ -18,12 +18,12 @@
 
 <script lang="ts">
     import { ArrowLeft, Plus, X } from "lucide-svelte";
-    import Button from "$lib/components/ui/button/button.svelte";
-    import { lobb } from "$lib";
+    import Button from "../../ui/button/button.svelte";
+    import { lobb } from "../../..";
     import { toast } from "svelte-sonner";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../../store.svelte";
     import ExtensionsComponents from "../../extensionsComponents.svelte";
-    import { getExtensionUtils } from "$lib/extensions/extensionUtils";
+    import { getExtensionUtils } from "../../../extensions/extensionUtils";
     import { getField, getFieldIcon } from "../../dataTable/utils";
     import Children from "./children.svelte";
     import {
@@ -34,8 +34,8 @@
     } from "../utils";
     import type { Snippet } from "svelte";
     import FieldInput from "../fieldInput.svelte";
-    import { emitEvent } from "$lib/eventSystem";
-    import Drawer from "$lib/components/drawer.svelte";
+    import { emitEvent } from "../../../eventSystem";
+    import Drawer from "../../drawer.svelte";
 
     let {
         collectionName,

package/dist/components/detailView/create/createDetailView.svelte.d.ts

@@ -0,0 +1,18 @@
+interface SubmitButton {
+    text: string;
+    icon: any;
+}
+export interface CreateDetailViewProp {
+    collectionName: string;
+    values?: Record<string, any>;
+    showRelatedRecords?: boolean;
+    rollback?: boolean;
+    submitButton?: SubmitButton;
+    title?: Snippet<[string]>;
+    onSuccessfullSave?: (entry: any) => Promise<void>;
+    onCancel?: () => Promise<void>;
+}
+import type { Snippet } from "svelte";
+declare const CreateDetailView: import("svelte").Component<CreateDetailViewProp, {}, "">;
+type CreateDetailView = ReturnType<typeof CreateDetailView>;
+export default CreateDetailView;

package/{src/lib → dist}/components/detailView/create/createDetailViewButton.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import type { CreateDetailViewProp } from "./createDetailView.svelte";
-	import type { ButtonProps } from "$lib/components/ui/button/button.svelte";
-	import Button from "$lib/components/ui/button/button.svelte";
+	import type { ButtonProps } from "../../ui/button/button.svelte";
+	import Button from "../../ui/button/button.svelte";
     import { openCreateDetailView } from "../store.svelte";
 
 	interface LocalProp extends CreateDetailViewProp {

package/dist/components/detailView/create/createDetailViewButton.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { CreateDetailViewProp } from "./createDetailView.svelte";
+import type { ButtonProps } from "../../ui/button/button.svelte";
+interface LocalProp extends CreateDetailViewProp {
+    variant?: ButtonProps["variant"];
+    class?: ButtonProps["class"];
+    Icon?: ButtonProps["Icon"];
+    children?: ButtonProps["children"];
+}
+declare const CreateDetailViewButton: import("svelte").Component<LocalProp, {}, "">;
+type CreateDetailViewButton = ReturnType<typeof CreateDetailViewButton>;
+export default CreateDetailViewButton;

package/{src/lib → dist}/components/detailView/create/createManyView.svelte

@@ -11,12 +11,12 @@
     import Table, { type TableProps } from "../../dataTable/table.svelte";
     import Button from "../../ui/button/button.svelte";
     import CreateDetailViewButton from "./createDetailViewButton.svelte";
-    import { getCollectionColumns } from "$lib/components/dataTable/utils";
-    import SelectRecord from "$lib/components/selectRecord.svelte";
-    import FieldCell from "$lib/components/dataTable/fieldCell.svelte";
+    import { getCollectionColumns } from "../../dataTable/utils";
+    import SelectRecord from "../../selectRecord.svelte";
+    import FieldCell from "../../dataTable/fieldCell.svelte";
     import SubRecords from "./subRecords.svelte";
-    import ChildRecords from "$lib/components/dataTable/childRecords.svelte";
-    import { ctx } from "$lib/store.svelte";
+    import ChildRecords from "../../dataTable/childRecords.svelte";
+    import { ctx } from "../../../store.svelte";
 
     interface ParentRecord {
         id: string;

package/dist/components/detailView/create/createManyView.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes } from "svelte/elements";
+interface ParentRecord {
+    id: string;
+    collectionName: string;
+}
+interface LocalProp {
+    parentCollectionName: string;
+    collectionName: string;
+    entries: any[];
+    parentRecord?: ParentRecord;
+    class?: HTMLAttributes<HTMLDivElement>["class"];
+    expanded?: boolean;
+}
+declare const CreateManyView: import("svelte").Component<LocalProp, {}, "entries">;
+type CreateManyView = ReturnType<typeof CreateManyView>;
+export default CreateManyView;

package/{src/lib → dist}/components/detailView/create/subRecords.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../../store.svelte";
     import CreateManyView from "./createManyView.svelte";
 
     interface Props {

package/dist/components/detailView/create/subRecords.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    collectionName: string;
+    parentEntry: any;
+    width: number;
+}
+declare const SubRecords: import("svelte").Component<Props, {}, "parentEntry">;
+type SubRecords = ReturnType<typeof SubRecords>;
+export default SubRecords;