@tulip-systems/core 0.8.3 → 0.10.0

package/dist/src/modules/router/handler/route.server.d.mts

@@ -0,0 +1,21 @@
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { TulipContext } from "../../config/lib/context.mjs";
+import { AnyRouter } from "@orpc/server";
+
+//#region src/modules/router/handler/route.server.d.ts
+/**
+ * RPC Route handler
+ */
+declare function handleRPCRoute<TRouter extends AnyRouter, TSchema extends TDatabaseSchema>(props: {
+  appRouter: TRouter;
+  context: TulipContext<TSchema>;
+}): {
+  HEAD: (request: Request) => Promise<Response>;
+  GET: (request: Request) => Promise<Response>;
+  POST: (request: Request) => Promise<Response>;
+  PUT: (request: Request) => Promise<Response>;
+  PATCH: (request: Request) => Promise<Response>;
+  DELETE: (request: Request) => Promise<Response>;
+};
+//#endregion
+export { handleRPCRoute };

package/dist/src/modules/router/handler/route.server.mjs

@@ -0,0 +1,32 @@
+import { createRPCContext } from "./context.server.mjs";
+import { onError } from "@orpc/client";
+import { RPCHandler } from "@orpc/server/fetch";
+
+//#region src/modules/router/handler/route.server.ts
+/**
+* RPC Route handler
+*/
+function handleRPCRoute(props) {
+	const handler = new RPCHandler(props.appRouter, { interceptors: [onError((error) => {
+		console.error(JSON.stringify(error));
+	})] });
+	async function handleRequest(request) {
+		const rpcContext = await createRPCContext({ context: props.context });
+		const { response } = await handler.handle(request, {
+			prefix: "/api/rpc",
+			context: rpcContext
+		});
+		return response ?? new Response("Not found", { status: 404 });
+	}
+	return {
+		HEAD: handleRequest,
+		GET: handleRequest,
+		POST: handleRequest,
+		PUT: handleRequest,
+		PATCH: handleRequest,
+		DELETE: handleRequest
+	};
+}
+
+//#endregion
+export { handleRPCRoute };

package/dist/src/modules/router/lib/error.server.d.mts

@@ -0,0 +1,2 @@
+import { ORPCError as ServerError } from "@orpc/server";
+export { ServerError };

package/dist/src/modules/router/lib/error.server.mjs

@@ -0,0 +1,3 @@
+import { ORPCError as ServerError } from "@orpc/server";
+
+export { ServerError };

package/dist/src/modules/router/lib/helpers.mjs

@@ -0,0 +1,7 @@
+import { StandardRPCJsonSerializer } from "@orpc/client/standard";
+
+//#region src/modules/router/lib/helpers.ts
+const serializer = new StandardRPCJsonSerializer();
+
+//#endregion
+export { serializer };

package/dist/src/modules/router/lib/query-client.d.mts

@@ -0,0 +1,10 @@
+import { QueryClient } from "@tanstack/react-query";
+
+//#region src/modules/router/lib/query-client.d.ts
+/**
+ * Create a new query client
+ */
+declare function createQueryClient(): QueryClient;
+declare function getQueryClient(): QueryClient;
+//#endregion
+export { createQueryClient, getQueryClient };

package/dist/src/modules/router/lib/query-client.mjs

@@ -0,0 +1,50 @@
+import { serializer } from "./helpers.mjs";
+import { MutationCache, QueryClient, environmentManager } from "@tanstack/react-query";
+
+//#region src/modules/router/lib/query-client.ts
+/**
+* Create a new query client
+*/
+function createQueryClient() {
+	let queryClient;
+	queryClient = new QueryClient({
+		defaultOptions: {
+			queries: {
+				queryKeyHashFn(queryKey) {
+					const [json, meta] = serializer.serialize(queryKey);
+					return JSON.stringify({
+						json,
+						meta
+					});
+				},
+				staleTime: 60 * 1e3
+			},
+			dehydrate: { serializeData(data) {
+				const [json, meta] = serializer.serialize(data);
+				return {
+					json,
+					meta
+				};
+			} },
+			hydrate: { deserializeData(data) {
+				return serializer.deserialize(data.json, data.meta);
+			} }
+		},
+		mutationCache: new MutationCache({ onSuccess: () => {
+			queryClient.invalidateQueries();
+		} })
+	});
+	return queryClient;
+}
+/**
+*  Create a stable getter for the query client that will return the same client during the same request.
+*/
+let browserQueryClient;
+function getQueryClient() {
+	if (environmentManager.isServer()) return createQueryClient();
+	if (!browserQueryClient) browserQueryClient = createQueryClient();
+	return browserQueryClient;
+}
+
+//#endregion
+export { createQueryClient, getQueryClient };

package/dist/src/modules/router/lib/query-client.server.d.mts

@@ -0,0 +1,17 @@
+import { createQueryClient } from "./query-client.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import "server-cli-only";
+
+//#region src/modules/router/lib/query-client.server.d.ts
+/**
+ *  Create a stable getter for the query client that will return the same client during the same request.
+ */
+declare const getQueryClient: typeof createQueryClient;
+/**
+ * Hydrate the client with the data from the server
+ */
+declare function HydrateClient(props: {
+  children: React.ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { HydrateClient, getQueryClient };

package/dist/src/modules/router/lib/query-client.server.mjs

@@ -0,0 +1,23 @@
+import { createQueryClient } from "./query-client.mjs";
+import { jsx } from "react/jsx-runtime";
+import { cache } from "react";
+import { HydrationBoundary, dehydrate } from "@tanstack/react-query";
+import "server-cli-only";
+
+//#region src/modules/router/lib/query-client.server.tsx
+/**
+*  Create a stable getter for the query client that will return the same client during the same request.
+*/
+const getQueryClient = cache(createQueryClient);
+/**
+* Hydrate the client with the data from the server
+*/
+function HydrateClient(props) {
+	return /* @__PURE__ */ jsx(HydrationBoundary, {
+		state: dehydrate(getQueryClient()),
+		children: props.children
+	});
+}
+
+//#endregion
+export { HydrateClient, getQueryClient };

package/dist/src/modules/router/lib/validators.d.mts

@@ -0,0 +1,12 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/router/lib/validators.d.ts
+/**
+ * Bulk action schema
+ */
+declare const bulkActionSchema: z$1.ZodObject<{
+  ids: z$1.ZodArray<z$1.ZodString>;
+}, z$1.core.$strip>;
+type BulkActionSchema = z$1.infer<typeof bulkActionSchema>;
+//#endregion
+export { BulkActionSchema, bulkActionSchema };

package/dist/src/modules/router/lib/validators.mjs

@@ -0,0 +1,10 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/router/lib/validators.ts
+/**
+* Bulk action schema
+*/
+const bulkActionSchema = z$1.object({ ids: z$1.array(z$1.string()) });
+
+//#endregion
+export { bulkActionSchema };

package/dist/src/modules/storage/components/dropzone-context.client.d.mts

@@ -0,0 +1,18 @@
+import * as react from "react";
+import { DropzoneOptions } from "react-dropzone";
+
+//#region src/modules/storage/components/dropzone-context.client.d.ts
+type DropzoneContextType = {
+  src?: File[];
+  accept?: DropzoneOptions["accept"];
+  maxSize?: DropzoneOptions["maxSize"];
+  minSize?: DropzoneOptions["minSize"];
+  maxFiles?: DropzoneOptions["maxFiles"];
+};
+declare const DropzoneContext: react.Context<DropzoneContextType | undefined>;
+/**
+ * Dropzone context hook
+ */
+declare function useDropzoneContext(): DropzoneContextType;
+//#endregion
+export { DropzoneContext, useDropzoneContext };

package/dist/src/modules/storage/components/dropzone-context.client.mjs

@@ -0,0 +1,17 @@
+"use client";
+
+import { createContext, use } from "react";
+
+//#region src/modules/storage/components/dropzone-context.client.tsx
+const DropzoneContext = createContext(void 0);
+/**
+* Dropzone context hook
+*/
+function useDropzoneContext() {
+	const context = use(DropzoneContext);
+	if (!context) throw new Error("useDropzoneContext must be used within a Dropzone");
+	return context;
+}
+
+//#endregion
+export { DropzoneContext, useDropzoneContext };

package/dist/src/modules/storage/components/dropzone.client.d.mts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+import { ReactNode } from "react";
+import { DropEvent, DropzoneOptions, FileRejection } from "react-dropzone";
+
+//#region src/modules/storage/components/dropzone.client.d.ts
+/**
+ * Dropzone
+ */
+type DropzoneProps = Omit<DropzoneOptions, "onDrop"> & {
+  src?: File[];
+  className?: string;
+  onDrop?: (acceptedFiles: File[], fileRejections: FileRejection[], event: DropEvent) => void;
+  children?: ReactNode;
+};
+declare function Dropzone({
+  accept,
+  maxFiles,
+  maxSize,
+  minSize,
+  onDrop,
+  onError,
+  disabled,
+  src,
+  className,
+  children,
+  ...props
+}: DropzoneProps): react_jsx_runtime0.JSX.Element;
+/**
+ * DropzoneContent
+ */
+type DropzoneContentProps = {
+  children?: ReactNode;
+  className?: string;
+};
+declare function DropzoneContent({
+  children,
+  className
+}: DropzoneContentProps): string | number | bigint | true | react_jsx_runtime0.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+/**
+ * DropzoneEmptyState
+ */
+type DropzoneEmptyStateProps = {
+  children?: ReactNode;
+  className?: string;
+};
+declare function DropzoneEmptyState({
+  children,
+  className
+}: DropzoneEmptyStateProps): string | number | bigint | true | react_jsx_runtime0.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+//#endregion
+export { Dropzone, DropzoneContent, DropzoneContentProps, DropzoneEmptyState, DropzoneEmptyStateProps, DropzoneProps };

package/dist/src/modules/storage/components/dropzone.client.mjs

@@ -0,0 +1,110 @@
+"use client";
+
+import { cn } from "../../../lib/utils/cn.mjs";
+import { Button } from "../../../components/ui/button.mjs";
+import { renderBytes } from "../lib/helpers.mjs";
+import { DropzoneContext, useDropzoneContext } from "./dropzone-context.client.mjs";
+import { UploadIcon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useDropzone } from "react-dropzone";
+
+//#region src/modules/storage/components/dropzone.client.tsx
+function Dropzone({ accept, maxFiles = 1, maxSize, minSize, onDrop, onError, disabled, src, className, children, ...props }) {
+	const { getRootProps, getInputProps, isDragActive } = useDropzone({
+		accept,
+		maxFiles,
+		maxSize,
+		minSize,
+		onError,
+		disabled,
+		onDrop: (acceptedFiles, fileRejections, event) => {
+			if (fileRejections.length > 0) {
+				const message = fileRejections.at(0)?.errors.at(0)?.message;
+				onError?.(new Error(message));
+				return;
+			}
+			onDrop?.(acceptedFiles, fileRejections, event);
+		},
+		...props
+	});
+	return /* @__PURE__ */ jsx(DropzoneContext, {
+		value: {
+			src,
+			accept,
+			maxSize,
+			minSize,
+			maxFiles
+		},
+		children: /* @__PURE__ */ jsxs(Button, {
+			className: cn("relative h-auto w-full flex-col overflow-hidden p-8", isDragActive && "outline-none ring-1 ring-ring", className),
+			disabled,
+			type: "button",
+			variant: "outline",
+			...getRootProps(),
+			children: [/* @__PURE__ */ jsx("input", {
+				...getInputProps(),
+				disabled
+			}), children]
+		})
+	}, JSON.stringify(src));
+}
+const maxLabelItems = 3;
+function DropzoneContent({ children, className }) {
+	const { src } = useDropzoneContext();
+	if (!src) return null;
+	if (children) return children;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex flex-col items-center justify-center", className),
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "flex size-8 items-center justify-center rounded-md bg-muted text-muted-foreground",
+				children: /* @__PURE__ */ jsx(UploadIcon, { size: 16 })
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "my-2 w-full truncate font-medium text-sm",
+				children: src.length > maxLabelItems ? `${new Intl.ListFormat("en").format(src.slice(0, maxLabelItems).map((file) => file.name))} and ${src.length - maxLabelItems} more` : new Intl.ListFormat("en").format(src.map((file) => file.name))
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "w-full text-wrap text-muted-foreground text-xs",
+				children: "Drag and drop or click to replace"
+			})
+		]
+	});
+}
+function DropzoneEmptyState({ children, className }) {
+	const { src, accept, maxSize, minSize, maxFiles } = useDropzoneContext();
+	if (src) return null;
+	if (children) return children;
+	let caption = "";
+	if (accept) {
+		caption += "Accepts ";
+		caption += new Intl.ListFormat("en").format(Object.keys(accept));
+	}
+	if (minSize && maxSize) caption += ` between ${renderBytes(minSize)} and ${renderBytes(maxSize)}`;
+	else if (minSize) caption += ` at least ${renderBytes(minSize)}`;
+	else if (maxSize) caption += ` less than ${renderBytes(maxSize)}`;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex flex-col items-center justify-center", className),
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "flex size-8 items-center justify-center rounded-md bg-muted text-muted-foreground",
+				children: /* @__PURE__ */ jsx(UploadIcon, { size: 16 })
+			}),
+			/* @__PURE__ */ jsxs("p", {
+				className: "my-2 w-full truncate text-wrap font-medium text-sm",
+				children: ["Upload ", maxFiles === 1 ? "a file" : "files"]
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "w-full truncate text-wrap text-muted-foreground text-xs",
+				children: "Drag and drop or click to upload"
+			}),
+			caption && /* @__PURE__ */ jsxs("p", {
+				className: "text-wrap text-muted-foreground text-xs",
+				children: [caption, "."]
+			})
+		]
+	});
+}
+
+//#endregion
+export { Dropzone, DropzoneContent, DropzoneEmptyState };

package/dist/src/modules/storage/components/image-grid.client.d.mts

@@ -0,0 +1,32 @@
+import { StorageAsset } from "../lib/validators.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ComponentProps } from "react";
+
+//#region src/modules/storage/components/image-grid.client.d.ts
+/**
+ * Image Grid
+ */
+type ImageGridProps = ComponentProps<"div"> & {
+  assets: StorageAsset[];
+  disabled?: boolean;
+  moveAction: (params: {
+    fromIndex: number;
+    toIndex: number;
+  }) => Promise<void>;
+  optimistic?: {
+    move?: (params: {
+      fromIndex: number;
+      toIndex: number;
+    }) => Promise<void> | void;
+  };
+};
+declare function ImageGrid({
+  assets,
+  moveAction,
+  optimistic,
+  disabled,
+  ...props
+}: ImageGridProps): react_jsx_runtime0.JSX.Element;
+declare function ImageGridSkeleton(props: ComponentProps<"div">): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { ImageGrid, ImageGridSkeleton };

package/dist/src/modules/storage/components/image-grid.client.mjs

@@ -0,0 +1,167 @@
+"use client";
+
+import { Icons } from "../../../components/common/icons.mjs";
+import { cn } from "../../../lib/utils/cn.mjs";
+import { Button } from "../../../components/ui/button.mjs";
+import { getAssetURL } from "../lib/helpers.mjs";
+import { Skeleton } from "../../../components/ui/skeleton.mjs";
+import { Input } from "../../../components/ui/input.mjs";
+import { Carousel, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious } from "../../../components/ui/carousel.client.mjs";
+import { Dialog, DialogContent, DialogTrigger } from "../../../components/ui/dialog.client.mjs";
+import { Card } from "../../../components/ui/card.mjs";
+import { useAction } from "../../../lib/hooks/use-action.mjs";
+import { StorageImage } from "./image.client.mjs";
+import { useUploadZone } from "./upload-zone-context.client.mjs";
+import { GripIcon, UploadIcon } from "lucide-react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import React from "react";
+import { SortableContext, rectSortingStrategy, sortableKeyboardCoordinates, useSortable } from "@dnd-kit/sortable";
+import { DndContext, KeyboardSensor, PointerSensor, closestCenter, useDroppable, useSensor, useSensors } from "@dnd-kit/core";
+import { CSS } from "@dnd-kit/utilities";
+
+//#region src/modules/storage/components/image-grid.client.tsx
+function ImageGrid({ assets, moveAction, optimistic, disabled, ...props }) {
+	const uploadZone = useUploadZone();
+	const images = assets.flatMap((asset) => ({
+		...asset,
+		url: getAssetURL(asset.id)
+	}));
+	const [current, setCurrent] = React.useState(0);
+	const { setNodeRef } = useDroppable({ id: "image-grid" });
+	const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }));
+	const moveMuration = useAction({
+		mutationFn: async ({ active, over }) => {
+			if (!moveAction) return Promise.resolve();
+			const activeId = active.id;
+			const overId = over?.id;
+			if (!activeId || !overId || activeId === overId) return Promise.resolve();
+			const fromIndex = images.findIndex((image) => image.id === activeId);
+			const toIndex = images.findIndex((image) => image.id === overId);
+			await optimistic?.move?.({
+				fromIndex,
+				toIndex
+			});
+			await moveAction({
+				fromIndex,
+				toIndex
+			});
+		},
+		onSuccess: async () => {
+			setCurrent(0);
+			await uploadZone.optimistic?.invalidate?.();
+		},
+		onError: (error) => {
+			console.error("Error moving image:", error);
+		}
+	});
+	return /* @__PURE__ */ jsxs(Dialog, {
+		...props,
+		children: [/* @__PURE__ */ jsx(DndContext, {
+			sensors,
+			collisionDetection: closestCenter,
+			onDragEnd: moveMuration.mutate,
+			children: /* @__PURE__ */ jsx("div", {
+				ref: setNodeRef,
+				className: "grid grid-cols-[repeat(auto-fill,minmax(10rem,1fr))] gap-5",
+				children: /* @__PURE__ */ jsxs(SortableContext, {
+					items: images.map((image) => image.id),
+					strategy: rectSortingStrategy,
+					children: [images.map((asset, index) => /* @__PURE__ */ jsx(ImageGridItem, {
+						asset,
+						index,
+						setCurrent
+					}, asset.id)), !disabled && /* @__PURE__ */ jsxs("label", {
+						htmlFor: "file-upload",
+						className: "relative flex aspect-square w-full cursor-pointer flex-col items-center justify-center rounded-lg border border-muted-foreground border-dashed bg-muted hover:border-primary",
+						children: [/* @__PURE__ */ jsx(UploadIcon, { className: "h-8 w-8" }), /* @__PURE__ */ jsx(Input, {
+							id: "file-upload",
+							type: "file",
+							accept: "image/jpeg, image/png, image/webp, image/gif",
+							className: "absolute inset-0 z-10 h-full w-full cursor-pointer opacity-0",
+							multiple: true,
+							onChange: (e) => {
+								if (!e.target.files) return;
+								return Array.from(e.target.files).map(uploadZone.onUpload);
+							}
+						})]
+					})]
+				})
+			})
+		}), /* @__PURE__ */ jsx(Carousel, {
+			className: "w-full",
+			opts: { startIndex: current },
+			children: /* @__PURE__ */ jsxs(DialogContent, {
+				className: "border-none bg-transparent p-0 shadow-none md:max-w-[80vw] xl:max-w-[60vw]",
+				children: [
+					/* @__PURE__ */ jsx(CarouselContent, {
+						className: "md:max-h-[80vh]",
+						children: images.map(({ id, url }) => /* @__PURE__ */ jsx(CarouselItem, {
+							className: "overflow-hidden rounded-xl",
+							children: /* @__PURE__ */ jsx(StorageImage, {
+								src: url,
+								alt: "Image Preview",
+								width: 1920,
+								height: 1080,
+								className: "h-full w-full rounded-xl object-contain"
+							})
+						}, id))
+					}),
+					/* @__PURE__ */ jsx(CarouselPrevious, {}),
+					/* @__PURE__ */ jsx(CarouselNext, {})
+				]
+			})
+		})]
+	});
+}
+function ImageGridItem({ asset, index, setCurrent }) {
+	const uploadZone = useUploadZone();
+	const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id: asset.id });
+	return /* @__PURE__ */ jsx(Card, {
+		id: asset.id,
+		ref: setNodeRef,
+		style: {
+			transform: CSS.Transform.toString(transform),
+			transition
+		},
+		className: cn("group relative aspect-square w-full", asset.status === "pending" && "opacity-30"),
+		children: asset.status === "ready" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsx(DialogTrigger, {
+				onClick: () => setCurrent(index),
+				children: /* @__PURE__ */ jsx(StorageImage, {
+					src: asset.url,
+					alt: "Image Preview",
+					width: 100,
+					height: 100,
+					className: "absolute inset-0 h-full w-full cursor-pointer rounded-lg bg-muted object-contain"
+				})
+			}),
+			/* @__PURE__ */ jsx(Button, {
+				...attributes,
+				...listeners,
+				type: "button",
+				variant: "secondary",
+				size: "icon",
+				className: "absolute top-2 right-2 hidden p-1 group-hover:flex",
+				children: /* @__PURE__ */ jsx(GripIcon, { className: "size-4" })
+			}),
+			/* @__PURE__ */ jsx(Button, {
+				type: "button",
+				variant: "destructive",
+				size: "icon",
+				onClick: () => uploadZone.onRemove([asset.id]),
+				className: "absolute top-2 left-2 hidden p-1 group-hover:flex",
+				children: /* @__PURE__ */ jsx(Icons.trash, { className: "size-4" })
+			})
+		] }) : /* @__PURE__ */ jsx(Skeleton, { className: "absolute inset-0 h-full w-full rounded-lg" })
+	});
+}
+function ImageGridSkeleton(props) {
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		className: cn("grid grid-cols-[repeat(auto-fill,minmax(10rem,1fr))] gap-5", props.className),
+		children: Array.from({ length: 12 }).map((_, index) => /* @__PURE__ */ jsx(Skeleton, { className: "aspect-square w-full rounded-lg" }, index))
+	});
+}
+
+//#endregion
+export { ImageGrid, ImageGridSkeleton };

package/dist/src/modules/storage/components/image.client.d.mts

@@ -0,0 +1,7 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ImageProps } from "next/image";
+
+//#region src/modules/storage/components/image.client.d.ts
+declare function StorageImage(props: Omit<ImageProps, "loader">): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { StorageImage };

package/dist/src/modules/storage/components/image.client.mjs

@@ -0,0 +1,16 @@
+"use client";
+
+import { imageLoader } from "../lib/helpers.mjs";
+import { jsx } from "react/jsx-runtime";
+import Image from "next/image";
+
+//#region src/modules/storage/components/image.client.tsx
+function StorageImage(props) {
+	return /* @__PURE__ */ jsx(Image, {
+		...props,
+		loader: imageLoader
+	});
+}
+
+//#endregion
+export { StorageImage };

package/dist/src/modules/storage/components/upload-button.client.d.mts

@@ -0,0 +1,11 @@
+import { Button } from "../../../components/ui/button.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ComponentProps } from "react";
+
+//#region src/modules/storage/components/upload-button.client.d.ts
+declare function UploadButton({
+  className,
+  ...props
+}: ComponentProps<typeof Button>): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { UploadButton };