@tulip-systems/drive 0.8.1 → 0.8.3

package/dist/providers/local/components/provider.client.d.mts

@@ -0,0 +1,39 @@
+import { DriveSelectionContextValue } from "../../../components/selection.client.mjs";
+import { DriveViewProviderProps } from "../../../components/view.client.mjs";
+import { DriveContextValue } from "../../../components/context.client.mjs";
+import { DriveDragDropProviderProps } from "../../../components/dnd.client.mjs";
+import { LocalDriveUploadZoneProps } from "./upload-zone.client.mjs";
+import * as react from "react";
+import { PropsWithChildren } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/providers/local/components/provider.client.d.ts
+type LocalDriveContextValue = DriveContextValue & {
+  readonly?: boolean;
+};
+declare const LocalDriveContext: react.Context<LocalDriveContextValue>;
+declare function useLocalDriveContext(): LocalDriveContextValue;
+type LocalDriveProviderProps = PropsWithChildren<LocalDriveContextValue & Partial<DriveSelectionContextValue> & Pick<DriveViewProviderProps, "initialView"> & Pick<DriveDragDropProviderProps, "onMove"> & Pick<LocalDriveUploadZoneProps, "driveUploadClient" | "uploadHooks" | "onUploadCompleted" | "onUploadFailed" | "optimistic" | "disabled" | "className"> & {
+  parentId?: string | null;
+}>;
+declare function LocalDriveProvider({
+  initialView,
+  namespace,
+  parentId,
+  permission,
+  meta,
+  readonly,
+  selection,
+  selectionConditions,
+  onMove,
+  driveUploadClient,
+  uploadHooks,
+  onUploadCompleted,
+  onUploadFailed,
+  optimistic,
+  disabled,
+  className,
+  children
+}: LocalDriveProviderProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { LocalDriveContext, LocalDriveContextValue, LocalDriveProvider, LocalDriveProviderProps, useLocalDriveContext };

package/dist/providers/local/components/provider.client.mjs

@@ -0,0 +1,60 @@
+"use client";
+
+import { DriveSelectionProvider } from "../../../components/selection.client.mjs";
+import { DriveViewProvider } from "../../../components/view.client.mjs";
+import { DriveDragDropProvider } from "../../../components/dnd.client.mjs";
+import { LocalDriveUploadZone } from "./upload-zone.client.mjs";
+import { cn } from "@tulip-systems/core/lib";
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Allowed } from "@tulip-systems/core/auth/client";
+
+//#region src/providers/local/components/provider.client.tsx
+const LocalDriveContext = createContext({});
+function useLocalDriveContext() {
+	const context = use(LocalDriveContext);
+	if (!context) throw new Error("LocalDriveContext not found!");
+	return context;
+}
+function LocalDriveProvider({ initialView = "grid", namespace, parentId, permission, meta, readonly = false, selection, selectionConditions, onMove, driveUploadClient, uploadHooks, onUploadCompleted, onUploadFailed, optimistic, disabled, className, children }) {
+	const isDisabled = disabled ?? readonly;
+	return /* @__PURE__ */ jsx(Allowed, {
+		permission,
+		children: /* @__PURE__ */ jsx(DriveSelectionProvider, {
+			selection,
+			selectionConditions,
+			children: /* @__PURE__ */ jsx(DriveViewProvider, {
+				initialView,
+				children: /* @__PURE__ */ jsx(DriveDragDropProvider, {
+					disabled: isDisabled,
+					onMove,
+					children: /* @__PURE__ */ jsx(LocalDriveContext, {
+						value: {
+							namespace,
+							permission,
+							meta,
+							readonly
+						},
+						children: /* @__PURE__ */ jsx(LocalDriveUploadZone, {
+							disabled: isDisabled,
+							className: cn("flex min-h-dvh flex-col", className),
+							variables: {
+								namespace,
+								parentId
+							},
+							driveUploadClient,
+							uploadHooks,
+							onUploadCompleted,
+							onUploadFailed,
+							optimistic,
+							children
+						})
+					})
+				})
+			})
+		})
+	});
+}
+
+//#endregion
+export { LocalDriveContext, LocalDriveProvider, useLocalDriveContext };

package/dist/providers/local/components/upload-zone-context.client.d.mts

@@ -0,0 +1,37 @@
+import { LocalDriveFileNode, LocalDriveNodeWithAsset } from "../lib/validators.mjs";
+import { LocalDriveUploadClient } from "../lib/upload.client.mjs";
+import React from "react";
+
+//#region src/providers/local/components/upload-zone-context.client.d.ts
+/**
+ * Upload Zone Context Value
+ */
+type LocalDriveUploadZoneContextValue = {
+  driveUploadClient: LocalDriveUploadClient;
+  onUpload: (file: File) => Promise<LocalDriveFileNode>;
+  onRemove: (ids: string[]) => Promise<void>;
+  optimistic?: {
+    add?: (newValue: LocalDriveNodeWithAsset) => Promise<void> | void;
+    replace?: (input: {
+      id: string;
+      newValue: LocalDriveNodeWithAsset;
+    }) => Promise<void> | void;
+    remove?: (ids: string[]) => Promise<void> | void;
+    invalidate?: () => Promise<void> | void;
+    cancel?: () => Promise<void> | void;
+  };
+  disabled?: boolean;
+};
+/**
+ * Upload Zone Context
+ */
+declare const LocalDriveUploadZoneContext: React.Context<LocalDriveUploadZoneContextValue | null>;
+type DriveUploadZoneContextValue = LocalDriveUploadZoneContextValue;
+declare const DriveUploadZoneContext: React.Context<LocalDriveUploadZoneContextValue | null>;
+/**
+ * Upload Zone Hook
+ */
+declare function useLocalDriveUploadZone(): LocalDriveUploadZoneContextValue;
+declare const useDriveUploadZone: typeof useLocalDriveUploadZone;
+//#endregion
+export { DriveUploadZoneContext, DriveUploadZoneContextValue, LocalDriveUploadZoneContext, LocalDriveUploadZoneContextValue, useDriveUploadZone, useLocalDriveUploadZone };

package/dist/providers/local/components/upload-zone-context.client.mjs

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

package/dist/providers/local/components/upload-zone.client.d.mts

@@ -0,0 +1,29 @@
+import { LocalDriveFileNode } from "../lib/validators.mjs";
+import { LocalDriveUploadHooks, PrepareLocalDriveUploadInput } from "../lib/upload.client.mjs";
+import { LocalDriveUploadZoneContextValue } from "./upload-zone-context.client.mjs";
+import { ComponentProps } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/providers/local/components/upload-zone.client.d.ts
+type LocalDriveUploadZoneProps = ComponentProps<"div"> & Pick<LocalDriveUploadZoneContextValue, "optimistic" | "driveUploadClient" | "disabled"> & {
+  variables: Pick<PrepareLocalDriveUploadInput, "namespace" | "parentId" | "readonly" | "hidden" | "visibility">;
+  uploadHooks?: LocalDriveUploadHooks;
+  onUploadCompleted?: (node: LocalDriveFileNode) => Promise<void> | void;
+  onUploadFailed?: (error: unknown) => Promise<void> | void;
+};
+type DriveUploadZoneProps = LocalDriveUploadZoneProps;
+declare function LocalDriveUploadZone({
+  variables,
+  optimistic,
+  driveUploadClient,
+  uploadHooks,
+  onUploadCompleted,
+  onUploadFailed,
+  disabled,
+  children,
+  className,
+  ...props
+}: LocalDriveUploadZoneProps): react_jsx_runtime0.JSX.Element;
+declare const DriveUploadZone: typeof LocalDriveUploadZone;
+//#endregion
+export { DriveUploadZone, DriveUploadZoneProps, LocalDriveUploadZone, LocalDriveUploadZoneProps };

package/dist/providers/local/components/upload-zone.client.mjs

@@ -0,0 +1,146 @@
+"use client";
+
+import { inferLocalDriveNodeSubtype } from "../lib/helpers.mjs";
+import { LocalDriveUploadZoneContext } from "./upload-zone-context.client.mjs";
+import { cn } from "@tulip-systems/core/lib";
+import { useCallback } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { toast } from "@tulip-systems/core/components/client";
+import { useAction } from "@tulip-systems/core/lib/client";
+import { useDropzone } from "react-dropzone";
+
+//#region src/providers/local/components/upload-zone.client.tsx
+function LocalDriveUploadZone({ variables, optimistic, driveUploadClient, uploadHooks, onUploadCompleted, onUploadFailed, disabled = false, children, className, ...props }) {
+	/**
+	* Delete mutation
+	*/
+	const deleteMutation = useAction({
+		mutationFn: async (ids) => driveUploadClient.deleteFiles(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) => driveUploadClient.upload(params, uploadHooks),
+		onMutate: async (variables) => {
+			await optimistic?.cancel?.();
+			const newNode = {
+				id: variables.uploadId,
+				provider: "local",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date(),
+				type: "file",
+				name: variables.file.name,
+				namespace: variables.namespace,
+				parentId: variables.parentId ?? null,
+				size: variables.file.size,
+				contentType: variables.file.type || "application/octet-stream",
+				readonly: variables.readonly ?? false,
+				hidden: variables.hidden ?? false,
+				archivedAt: null,
+				assetId: null,
+				subtype: inferLocalDriveNodeSubtype({
+					name: variables.file.name,
+					contentType: variables.file.type || "application/octet-stream"
+				}),
+				links: {
+					view: null,
+					download: null,
+					preview: null,
+					thumbnail: null
+				},
+				availability: "pending",
+				asset: {
+					status: "pending",
+					name: variables.file.name,
+					contentType: variables.file.type || "application/octet-stream",
+					size: variables.file.size,
+					visibility: variables.visibility || "private"
+				}
+			};
+			await optimistic?.add?.(newNode);
+		},
+		onSuccess: async (data, variables) => {
+			await optimistic?.replace?.({
+				id: variables.uploadId ?? "",
+				newValue: {
+					...data,
+					asset: {
+						status: "ready",
+						name: data.name,
+						contentType: data.contentType,
+						size: data.size,
+						visibility: variables.visibility || "private"
+					}
+				}
+			});
+			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 = driveUploadClient.prepareUpload({
+			...variables,
+			file
+		});
+		return await uploadMutation.mutateAsync(req);
+	}, [
+		driveUploadClient,
+		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(LocalDriveUploadZoneContext, {
+				value: {
+					driveUploadClient,
+					onUpload,
+					onRemove: deleteMutation.mutateAsync,
+					optimistic,
+					disabled
+				},
+				children
+			})
+		]
+	});
+}
+const DriveUploadZone = LocalDriveUploadZone;
+
+//#endregion
+export { DriveUploadZone, LocalDriveUploadZone };

package/dist/providers/local/components/view.client.d.mts

@@ -0,0 +1,31 @@
+import { LocalDriveNodeWithAsset } from "../lib/validators.mjs";
+import { TableColumnDef } from "@tulip-systems/core/data-tables";
+import { ComponentProps } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { useInfiniteStrategy } from "@tulip-systems/core/data-tables/client";
+import { CommandDef } from "@tulip-systems/core/commands";
+import { VisibilityState } from "@tanstack/react-table";
+
+//#region src/providers/local/components/view.client.d.ts
+type LocalDriveViewProviderProps<TData extends LocalDriveNodeWithAsset = LocalDriveNodeWithAsset> = ComponentProps<"div"> & {
+  queryData: TData[];
+  columns?: TableColumnDef<TData>[];
+  strategy: ReturnType<typeof useInfiniteStrategy>;
+  commands?: CommandDef<TData>[];
+  columnVisibility?: VisibilityState;
+};
+declare function LocalDriveViewProvider<TData extends LocalDriveNodeWithAsset = LocalDriveNodeWithAsset>({
+  queryData,
+  columns,
+  strategy,
+  commands,
+  columnVisibility,
+  children,
+  ...props
+}: LocalDriveViewProviderProps<TData>): react_jsx_runtime0.JSX.Element;
+declare function LocalDriveView(): react_jsx_runtime0.JSX.Element | null;
+declare function LocalDriveViewLoading({
+  ...props
+}: ComponentProps<"div">): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { LocalDriveView, LocalDriveViewLoading, LocalDriveViewProvider };

package/dist/providers/local/components/view.client.mjs

@@ -0,0 +1,90 @@
+"use client";
+
+import { useDriveSelectionContext } from "../../../components/selection.client.mjs";
+import { DriveGridCard, DriveGridCardSkeleton } from "../../../components/grid-card.client.mjs";
+import { DriveGrid, DriveGridBottombar, DriveGridEmpty, DriveGridLoading } from "../../../components/grid.client.mjs";
+import { useDriveViewContext } from "../../../components/view.client.mjs";
+import { localDriveColumns } from "../config/columns-data.mjs";
+import { localDriveImageLoader } from "../lib/helpers.mjs";
+import { useLocalDriveUploadZone } from "./upload-zone-context.client.mjs";
+import { useLocalDriveContext } from "./provider.client.mjs";
+import { TableLayout, TableSkeleton } from "@tulip-systems/core/data-tables";
+import { useMemo } from "react";
+import { FloatingCommandMenu } from "@tulip-systems/core/commands/client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { DataTable, TableConfigProvider, createTableConfig, useTableConfigContext } from "@tulip-systems/core/data-tables/client";
+
+//#region src/providers/local/components/view.client.tsx
+function LocalDriveViewProvider({ queryData, columns = localDriveColumns, strategy, commands, columnVisibility, children, ...props }) {
+	const { meta } = useLocalDriveContext();
+	const { selection } = useDriveSelectionContext();
+	return /* @__PURE__ */ jsx(TableConfigProvider, {
+		config: createTableConfig({
+			queryData,
+			columns,
+			strategy,
+			commands,
+			meta,
+			columnVisibility,
+			selection
+		}),
+		children: /* @__PURE__ */ jsx(TableLayout, {
+			...props,
+			children
+		})
+	});
+}
+function LocalDriveView() {
+	const { view } = useDriveViewContext();
+	if (view === "grid") return /* @__PURE__ */ jsx(LocalDriveGrid, {});
+	if (view === "list") return /* @__PURE__ */ jsx(LocalDriveList, {});
+	return null;
+}
+function LocalDriveGrid(props) {
+	const { queryData, strategy, commands, selection, meta } = useTableConfigContext();
+	const { optimistic } = useLocalDriveUploadZone();
+	const { rowCount, paginationState } = strategy;
+	const { isFetching, isFetchingNextPage, fetchNextPage } = strategy.meta;
+	const hasNextPage = rowCount == null ? false : queryData.length < rowCount;
+	const selectedData = useMemo(() => queryData.filter((node) => selection?.rowSelection?.[node.id] === true), [queryData, selection?.rowSelection]);
+	return /* @__PURE__ */ jsxs(DriveGrid, {
+		...props,
+		children: [
+			queryData.length > 0 ? queryData.filter((node) => !node.hidden).map((node) => /* @__PURE__ */ jsx(DriveGridCard, {
+				node,
+				commands,
+				imageLoader: localDriveImageLoader
+			}, node.id)) : /* @__PURE__ */ jsx(DriveGridEmpty, { title: "Geen resultaten gevonden" }),
+			isFetchingNextPage && Array.from({ length: paginationState?.pageSize ?? 0 }).map((_, index) => /* @__PURE__ */ jsx(DriveGridCardSkeleton, {}, index)),
+			/* @__PURE__ */ jsx(DriveGridBottombar, {
+				hasNextPage,
+				fetchNextPage,
+				isFetching,
+				isFetchingNextPage
+			}),
+			commands && commands.length > 0 && /* @__PURE__ */ jsx(FloatingCommandMenu, {
+				data: selectedData,
+				commands,
+				meta,
+				state: selectedData.length > 0 ? "open" : "closed",
+				onSuccess: () => {
+					selection?.setRowSelection?.({});
+					optimistic?.invalidate?.();
+				}
+			})
+		]
+	});
+}
+function LocalDriveList(props) {
+	return /* @__PURE__ */ jsx(DataTable, { ...props });
+}
+function LocalDriveViewLoading({ ...props }) {
+	const { view } = useDriveViewContext();
+	return /* @__PURE__ */ jsxs("div", {
+		...props,
+		children: [view === "grid" && /* @__PURE__ */ jsx(DriveGridLoading, { ...props }), view === "list" && /* @__PURE__ */ jsx(TableSkeleton, { ...props })]
+	});
+}
+
+//#endregion
+export { LocalDriveView, LocalDriveViewLoading, LocalDriveViewProvider };

package/dist/providers/local/config/columns-data.d.mts

@@ -0,0 +1,7 @@
+import { LocalDriveNodeWithAsset } from "../lib/validators.mjs";
+import { TableColumnDef } from "@tulip-systems/core/data-tables";
+
+//#region src/providers/local/config/columns-data.d.ts
+declare const localDriveColumns: TableColumnDef<LocalDriveNodeWithAsset>[];
+//#endregion
+export { localDriveColumns };

package/dist/providers/local/config/columns-data.mjs

@@ -0,0 +1,69 @@
+"use client";
+
+import { driveTreeSearchParams } from "../../../lib/search-params.mjs";
+import { nodeSubtypeConfig, nodeSubtypeVariants } from "../../../config/types.mjs";
+import { TableColumnHeader } from "@tulip-systems/core/data-tables";
+import { findStatus } from "@tulip-systems/core/components";
+import { FolderIcon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@tulip-systems/core/components/client";
+import { TableTextCell, createTableSelectCell } from "@tulip-systems/core/data-tables/client";
+import Link from "next/link";
+import { createSerializer, useQueryStates } from "nuqs";
+
+//#region src/providers/local/config/columns-data.tsx
+const localDriveColumns = [
+	createTableSelectCell(),
+	{
+		id: "icon",
+		accessorKey: "icon",
+		header: () => null,
+		cell: ({ row }) => {
+			if (row.original.type === "file") {
+				const subtype = findStatus(nodeSubtypeConfig, row.original.subtype);
+				if (!subtype) return null;
+				return /* @__PURE__ */ jsx(TableTextCell, {
+					className: "w-4",
+					children: /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, { children: /* @__PURE__ */ jsx(subtype.icon, { className: nodeSubtypeVariants({
+						status: row.original.subtype,
+						className: "size-4"
+					}) }) }), /* @__PURE__ */ jsx(TooltipContent, { children: subtype.label })] })
+				});
+			}
+			if (row.original.type === "folder") return /* @__PURE__ */ jsx(TableTextCell, {
+				className: "w-4",
+				children: /* @__PURE__ */ jsx(FolderIcon, { className: "w-4 min-w-4" })
+			});
+			return null;
+		},
+		enableSorting: false
+	},
+	{
+		id: "name",
+		accessorKey: "name",
+		header: ({ column }) => /* @__PURE__ */ jsx(TableColumnHeader, {
+			column,
+			title: "Naam"
+		}),
+		cell: ({ row }) => {
+			const [query] = useQueryStates(driveTreeSearchParams);
+			const serialize = createSerializer(driveTreeSearchParams);
+			return /* @__PURE__ */ jsx(TableTextCell, {
+				className: "w-full min-w-64",
+				children: /* @__PURE__ */ jsx(Link, {
+					href: row.original.type === "file" ? row.original.links.view ?? "#" : serialize({
+						...query,
+						parentId: row.original.id
+					}),
+					className: "truncate hover:underline",
+					target: row.original.type === "file" ? "_blank" : "_self",
+					children: row.getValue("name")
+				})
+			});
+		},
+		enableSorting: false
+	}
+];
+
+//#endregion
+export { localDriveColumns };

package/dist/providers/local/config/filters.d.mts

@@ -0,0 +1,25 @@
+import z$1 from "zod";
+import * as _tulip_systems_core_data_tables0 from "@tulip-systems/core/data-tables";
+
+//#region src/providers/local/config/filters.d.ts
+declare const localDriveFilters: {
+  subtypes: _tulip_systems_core_data_tables0.ParseFilter<z$1.ZodArray<z$1.ZodEnum<{
+    image: "image";
+    document: "document";
+    spreadsheet: "spreadsheet";
+    video: "video";
+    audio: "audio";
+    archive: "archive";
+    other: "other";
+  }>>>;
+  hidden: _tulip_systems_core_data_tables0.ParseFilter<z$1.ZodBoolean>;
+  types: _tulip_systems_core_data_tables0.ParseFilter<z$1.ZodArray<z$1.ZodEnum<{
+    file: "file";
+    folder: "folder";
+  }>>>;
+  contentTypes: _tulip_systems_core_data_tables0.ParseFilter<z$1.ZodArray<z$1.ZodString>>;
+  nodeIds: _tulip_systems_core_data_tables0.ParseFilter<z$1.ZodArray<z$1.ZodString>>;
+  isArchived: _tulip_systems_core_data_tables0.ParseFilter<z$1.ZodBoolean>;
+};
+//#endregion
+export { localDriveFilters };

package/dist/providers/local/config/filters.mjs

@@ -0,0 +1,14 @@
+import { driveTreeFilters } from "../../../config/filters.mjs";
+import { nodeSubtypes } from "../lib/constants.mjs";
+import z$1 from "zod";
+import { createTableFilters, parseFilterArray, parseFilterBoolean } from "@tulip-systems/core/data-tables";
+
+//#region src/providers/local/config/filters.ts
+const localDriveFilters = createTableFilters({
+	...driveTreeFilters,
+	subtypes: parseFilterArray(z$1.array(z$1.enum(nodeSubtypes))),
+	hidden: parseFilterBoolean(z$1.boolean())
+});
+
+//#endregion
+export { localDriveFilters };

package/dist/providers/local/lib/constants.d.mts

@@ -0,0 +1,11 @@
+//#region src/providers/local/lib/constants.d.ts
+declare const deviceSizes: number[];
+declare const imageSizes: number[];
+declare const imageVariants: readonly ["main", ...`preview-${number}`[]];
+type ImageVariant = (typeof imageVariants)[number];
+/**
+ * Node subtype
+ */
+declare const nodeSubtypes: readonly ["image", "document", "spreadsheet", "video", "audio", "archive", "other"];
+//#endregion
+export { ImageVariant, deviceSizes, imageSizes, imageVariants, nodeSubtypes };

package/dist/providers/local/lib/constants.mjs

@@ -0,0 +1,28 @@
+//#region src/providers/local/lib/constants.ts
+const deviceSizes = [
+	640,
+	750,
+	828,
+	1080,
+	1200,
+	1920,
+	2048,
+	3840
+];
+const imageSizes = deviceSizes;
+const imageVariants = ["main", ...deviceSizes.map((size) => `preview-${size}`)];
+/**
+* Node subtype
+*/
+const nodeSubtypes = [
+	"image",
+	"document",
+	"spreadsheet",
+	"video",
+	"audio",
+	"archive",
+	"other"
+];
+
+//#endregion
+export { deviceSizes, imageSizes, imageVariants, nodeSubtypes };

package/dist/providers/local/lib/helpers.d.mts

@@ -0,0 +1,44 @@
+import { GetLocalFileURLSchema, LocalDriveNode, LocalNode } from "./validators.mjs";
+import { nodeSubtypes } from "./constants.mjs";
+import { ImageLoaderProps } from "next/image";
+
+//#region src/providers/local/lib/helpers.d.ts
+/**
+ * Convert a LocalNode to LocalDriveNode by adding provider and links
+ * @param node The LocalNode to convert
+ * @returns The converted LocalDriveNode
+ */
+declare function toLocalDriveNode<TNode extends LocalNode>(node: TNode): LocalDriveNode;
+/**
+ * Check if the node is a file
+ */
+declare function isLocalDriveFile(node: Pick<LocalNode, "type">): node is LocalNode;
+/**
+ * Check if the node is a folder
+ */
+declare function isLocalDriveFolder(node: Pick<LocalNode, "type">): node is LocalNode;
+/**
+ * Get file url
+ */
+declare function getLocalDriveFileUrl(id: string, options?: Partial<GetLocalFileURLSchema>): string;
+/**
+ * Image loader
+ */
+declare function localDriveImageLoader({
+  src,
+  width
+}: ImageLoaderProps): string;
+/**
+ * Node subtype inference
+ */
+type LocalDriveNodeSubtype = (typeof nodeSubtypes)[number];
+declare function inferLocalDriveNodeSubtype({
+  name,
+  contentType
+}: Partial<Pick<LocalDriveNode, "name" | "contentType">>): LocalDriveNodeSubtype;
+/**
+ * Render bytes
+ */
+declare function renderBytes(bytes: number): string;
+//#endregion
+export { LocalDriveNodeSubtype, getLocalDriveFileUrl, inferLocalDriveNodeSubtype, isLocalDriveFile, isLocalDriveFolder, localDriveImageLoader, renderBytes, toLocalDriveNode };