@tulip-systems/core 0.8.3 → 0.9.0

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 };

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

@@ -0,0 +1,33 @@
+"use client";
+
+import { cn } from "../../../lib/utils/cn.mjs";
+import { Button } from "../../../components/ui/button.mjs";
+import { Input } from "../../../components/ui/input.mjs";
+import { useUploadZone } from "./upload-zone-context.client.mjs";
+import { UploadIcon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/modules/storage/components/upload-button.client.tsx
+function UploadButton({ className, ...props }) {
+	const { onUpload } = useUploadZone();
+	return /* @__PURE__ */ jsxs(Button, {
+		...props,
+		className: cn("relative gap-2", className),
+		children: [
+			/* @__PURE__ */ jsx(UploadIcon, { className: "h-3 w-3" }),
+			/* @__PURE__ */ jsx("span", { children: "Upload" }),
+			/* @__PURE__ */ jsx(Input, {
+				type: "file",
+				className: "absolute inset-0 z-10 h-full w-full cursor-pointer opacity-0",
+				multiple: true,
+				onChange: (e) => {
+					if (!e.target.files) return;
+					Array.from(e.target.files).forEach(onUpload);
+				}
+			})
+		]
+	});
+}
+
+//#endregion
+export { UploadButton };

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

@@ -0,0 +1,30 @@
+import { StorageAsset } from "../lib/validators.mjs";
+import { UploadClient } from "../lib/upload.client.mjs";
+import React from "react";
+
+//#region src/modules/storage/components/upload-zone-context.client.d.ts
+/**
+ * Upload Zone Context Value
+ */
+type UploadZoneContextValue = {
+  uploadClient: UploadClient;
+  onUpload: (file: File) => Promise<StorageAsset>;
+  onRemove: (ids: string[]) => Promise<void>;
+  optimistic?: {
+    add?: (newValue: Omit<StorageAsset, "id" | "key" | "bucket" | "provider" | "createdAt" | "updatedAt">) => Promise<void> | void;
+    remove?: (ids: string[]) => Promise<void> | void;
+    invalidate?: () => Promise<void> | void;
+    cancel?: () => Promise<void> | void;
+  };
+  disabled?: boolean;
+};
+/**
+ * Upload Zone Context
+ */
+declare const UploadZoneContext: React.Context<UploadZoneContextValue | null>;
+/**
+ * Upload Zone Hook
+ */
+declare function useUploadZone(): UploadZoneContextValue;
+//#endregion
+export { UploadZoneContext, UploadZoneContextValue, useUploadZone };

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

@@ -0,0 +1,20 @@
+"use client";
+
+import React from "react";
+
+//#region src/modules/storage/components/upload-zone-context.client.tsx
+/**
+* Upload Zone Context
+*/
+const UploadZoneContext = React.createContext(null);
+/**
+* Upload Zone Hook
+*/
+function useUploadZone() {
+	const context = React.useContext(UploadZoneContext);
+	if (!context) throw new Error("useUploadZone must be used within an UploadZoneContext provider");
+	return context;
+}
+
+//#endregion
+export { UploadZoneContext, useUploadZone };

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

@@ -0,0 +1,27 @@
+import { StorageAsset, UploadInput } from "../lib/validators.mjs";
+import { UploadHooks } from "../lib/upload.client.mjs";
+import { UploadZoneContextValue } from "./upload-zone-context.client.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ComponentProps } from "react";
+
+//#region src/modules/storage/components/upload-zone.client.d.ts
+type UploadZoneProps = ComponentProps<"div"> & Pick<UploadZoneContextValue, "optimistic" | "uploadClient" | "disabled"> & {
+  variables: Pick<UploadInput, "visibility">;
+  uploadHooks?: UploadHooks;
+  onUploadCompleted?: (asset: StorageAsset) => Promise<void> | void;
+  onUploadFailed?: (error: unknown) => Promise<void> | void;
+};
+declare function UploadZone({
+  variables,
+  optimistic,
+  uploadClient,
+  uploadHooks,
+  onUploadCompleted,
+  onUploadFailed,
+  disabled,
+  children,
+  className,
+  ...props
+}: UploadZoneProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { UploadZone, UploadZoneProps };

package/dist/src/modules/storage/components/upload-zone.client.mjs

@@ -0,0 +1,111 @@
+"use client";
+
+import { cn } from "../../../lib/utils/cn.mjs";
+import { toast } from "../../../components/ui/sonner.client.mjs";
+import { useAction } from "../../../lib/hooks/use-action.mjs";
+import { UploadZoneContext } from "./upload-zone-context.client.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { useDropzone } from "react-dropzone";
+
+//#region src/modules/storage/components/upload-zone.client.tsx
+function UploadZone({ variables, optimistic, uploadClient, uploadHooks, onUploadCompleted, onUploadFailed, disabled = false, children, className, ...props }) {
+	/**
+	* Delete mutation
+	*/
+	const deleteMutation = useAction({
+		mutationFn: async (ids) => {
+			await uploadClient.deleteAssets(ids);
+		},
+		onMutate: async (ids) => {
+			await optimistic?.cancel?.();
+			await optimistic?.remove?.(ids);
+		},
+		onError: async (error) => {
+			console.error("Delete failed upload error: ", error);
+			await onUploadFailed?.(error);
+		},
+		onSettled: () => {
+			optimistic?.invalidate?.();
+		}
+	});
+	/**
+	* Upload mutation
+	*/
+	const uploadMutation = useAction({
+		mutationFn: async (params) => uploadClient.upload(params, uploadHooks),
+		onMutate: async (variables) => {
+			await optimistic?.cancel?.();
+			const newAsset = {
+				...variables,
+				visibility: variables.visibility ?? "private",
+				status: "pending",
+				name: variables.file.name,
+				size: variables.file.size,
+				contentType: variables.file.type || "application/octet-stream",
+				etag: null,
+				metadata: null,
+				uploadedAt: /* @__PURE__ */ new Date(),
+				deletedAt: null
+			};
+			await optimistic?.add?.(newAsset);
+		},
+		onSuccess: async (data) => {
+			await onUploadCompleted?.(data);
+			toast.success(`Succesvol geupload: ${data.name}`);
+		},
+		onError: async (error) => {
+			await onUploadFailed?.(error);
+			console.error("Upload error: ", error);
+			toast.error("Bestand uploaden mislukt", { description: error instanceof Error ? error.message : void 0 });
+		},
+		onSettled: () => {
+			optimistic?.invalidate?.();
+		}
+	});
+	/**
+	* Upload file handler
+	*/
+	const onUpload = useCallback(async (file) => {
+		console.info("Uploading file", file);
+		const req = uploadClient.prepareUpload({
+			...variables,
+			file
+		});
+		return await uploadMutation.mutateAsync(req);
+	}, [
+		uploadClient,
+		variables,
+		uploadMutation
+	]);
+	const { getRootProps, getInputProps, isDragActive } = useDropzone({
+		onDrop: useCallback(async (acceptedFiles) => {
+			if (acceptedFiles.length === 0) return;
+			await Promise.allSettled(acceptedFiles.map(onUpload));
+		}, [onUpload]),
+		noClick: true,
+		disabled
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		...props,
+		...getRootProps(),
+		className: cn("relative z-0", className),
+		children: [
+			/* @__PURE__ */ jsx("input", { ...getInputProps() }),
+			isDragActive && /* @__PURE__ */ jsx("div", { className: "absolute inset-0 z-10 rounded-md bg-primary/20 opacity-70 backdrop-blur-3xl" }),
+			/* @__PURE__ */ jsx(UploadZoneContext, {
+				value: {
+					uploadClient,
+					onUpload,
+					onRemove: deleteMutation.mutateAsync,
+					optimistic,
+					disabled
+				},
+				children
+			})
+		]
+	});
+}
+
+//#endregion
+export { UploadZone };

package/dist/src/modules/storage/lib/constants.d.mts

@@ -0,0 +1,5 @@
+//#region src/modules/storage/lib/constants.d.ts
+declare const imageDispositions: readonly ["inline", "attachment"];
+type ImageDisposition = (typeof imageDispositions)[number];
+//#endregion
+export { ImageDisposition, imageDispositions };

package/dist/src/modules/storage/lib/constants.mjs

@@ -0,0 +1,5 @@
+//#region src/modules/storage/lib/constants.ts
+const imageDispositions = ["inline", "attachment"];
+
+//#endregion
+export { imageDispositions };

package/dist/src/modules/storage/lib/helpers.d.mts

@@ -0,0 +1,29 @@
+import { GetAssetURLInput } from "./validators.mjs";
+import { ImageLoaderProps } from "next/image";
+
+//#region src/modules/storage/lib/helpers.d.ts
+/**
+ * Builds the public API route URL for a storage file proxy request.
+ *
+ * Use this helper when you need a stable file URL in the client/UI
+ * without manually composing the route path.
+ *
+ * @param id - Storage asset id
+ * @returns File proxy URL for the storage route handler
+ * @example
+ * const url = getAssetURL("019d0051-2c0d-741e-9e3c-e5a5bc4d16a2", { disposition: "attachment" });
+ * // /api/storage/files/019d0051-2c0d-741e-9e3c-e5a5bc4d16a2?disposition=attachment
+ */
+declare function getAssetURL(id: string, options?: Partial<GetAssetURLInput>): string;
+/**
+ * Image loader
+ */
+declare function imageLoader({
+  src
+}: ImageLoaderProps): string;
+/**
+ * Render bytes
+ */
+declare function renderBytes(bytes: number): string;
+//#endregion
+export { getAssetURL, imageLoader, renderBytes };

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

@@ -0,0 +1,49 @@
+//#region src/modules/storage/lib/helpers.ts
+/**
+* Builds the public API route URL for a storage file proxy request.
+*
+* Use this helper when you need a stable file URL in the client/UI
+* without manually composing the route path.
+*
+* @param id - Storage asset id
+* @returns File proxy URL for the storage route handler
+* @example
+* const url = getAssetURL("019d0051-2c0d-741e-9e3c-e5a5bc4d16a2", { disposition: "attachment" });
+* // /api/storage/files/019d0051-2c0d-741e-9e3c-e5a5bc4d16a2?disposition=attachment
+*/
+function getAssetURL(id, options = {}) {
+	const searchParams = new URLSearchParams();
+	if (options?.disposition) searchParams.set("disposition", options.disposition);
+	const queryString = searchParams.toString();
+	return `/api/storage/files/${id}${queryString ? `?${queryString}` : ""}`;
+}
+/**
+* Image loader
+*/
+function imageLoader({ src }) {
+	if (typeof window === "undefined") return src;
+	return new URL(src, window.location.origin).toString();
+}
+/**
+* Render bytes
+*/
+function renderBytes(bytes) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB",
+		"PB"
+	];
+	let size = bytes;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex++;
+	}
+	return `${size.toFixed(2)}${units[unitIndex]}`;
+}
+
+//#endregion
+export { getAssetURL, imageLoader, renderBytes };