@m5kdev/frontend 0.1.0

package/dist/src/modules/auth/auth.lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.lib.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/auth.lib.ts"],"names":[],"mappings":"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"}

package/dist/src/modules/auth/auth.lib.js

@@ -0,0 +1,41 @@
+import { adminClient, inferAdditionalFields, lastLoginMethodClient, organizationClient, } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+const options = {
+    baseURL: import.meta.env.VITE_SERVER_URL,
+    plugins: [
+        lastLoginMethodClient(),
+        organizationClient({
+            teams: {
+                enabled: true,
+            },
+        }),
+        adminClient(),
+        inferAdditionalFields({
+            user: {
+                onboarding: {
+                    type: "number",
+                    required: false,
+                },
+                preferences: {
+                    type: "string",
+                    required: false,
+                },
+                flags: {
+                    type: "string",
+                    required: false,
+                },
+                stripeCustomerId: {
+                    type: "string",
+                    required: false,
+                },
+            },
+            teamMembers: {
+                role: {
+                    type: "string",
+                    required: true,
+                },
+            },
+        }),
+    ],
+};
+export const authClient = createAuthClient(options);

package/dist/src/modules/auth/components/AuthProvider.d.ts

@@ -0,0 +1,15 @@
+import { authClient } from "../auth.lib";
+type Session = ReturnType<typeof authClient.useSession>["data"];
+export declare const authProviderContext: import("react").Context<{
+    isLoading: boolean;
+    data: Session | null;
+    signOut: () => void;
+    registerSession: (onSuccess: () => void) => void;
+}>;
+export declare function AuthProvider({ children, loader, onSession, }: {
+    children: React.ReactNode;
+    loader?: React.ReactNode;
+    onSession?: (session: Session | null) => void;
+}): string | number | bigint | true | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=AuthProvider.d.ts.map

package/dist/src/modules/auth/components/AuthProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthProvider.d.ts","sourceRoot":"","sources":["../../../../../src/modules/auth/components/AuthProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAOhE,eAAO,MAAM,mBAAmB;eACnB,OAAO;UACZ,OAAO,GAAG,IAAI;aACX,MAAM,IAAI;qBACF,CAAC,SAAS,EAAE,MAAM,IAAI,KAAK,IAAI;EAMhD,CAAC;AAEH,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,MAAM,EACN,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,CAAC;CAC/C,qVAyEA"}

package/dist/src/modules/auth/components/AuthProvider.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { usePostHog } from "posthog-js/react";
+import { createContext, useCallback, useEffect, useState } from "react";
+import { authClient } from "../auth.lib";
+function isImpersonatedSession(session) {
+    const sessionData = session?.session;
+    return Boolean(sessionData?.impersonatedBy);
+}
+export const authProviderContext = createContext({
+    isLoading: true,
+    data: null,
+    signOut: () => { },
+    registerSession: () => { },
+});
+export function AuthProvider({ children, loader, onSession, }) {
+    const posthog = usePostHog();
+    const [isLoading, setIsLoading] = useState(true);
+    const [session, setSession] = useState(null);
+    const registerSession = useCallback((onSuccess) => {
+        authClient
+            .getSession()
+            .then(({ data: nextSession }) => {
+            setIsLoading(false);
+            setSession(nextSession);
+            onSession?.(nextSession);
+            if (isImpersonatedSession(nextSession)) {
+                posthog.opt_out_capturing();
+                posthog.reset();
+                onSuccess?.();
+                return;
+            }
+            posthog.opt_in_capturing();
+            if (nextSession?.user) {
+                posthog.identify(nextSession.user.id, {
+                    email: nextSession.user.email,
+                    name: nextSession.user.name,
+                    createdAt: nextSession.user.createdAt,
+                    updatedAt: nextSession.user.updatedAt,
+                    role: nextSession.user.role,
+                    image: nextSession.user.image,
+                    preferences: nextSession.user.preferences,
+                    onboarding: nextSession.user.onboarding,
+                    flags: nextSession.user.flags,
+                });
+            }
+            else {
+                posthog.reset();
+            }
+            onSuccess?.();
+        })
+            .catch((error) => {
+            console.error("Failed to get session:", error);
+            setIsLoading(false);
+            setSession(null);
+        });
+    }, [onSession, posthog]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies(registerSession): registerSession is a callback
+    useEffect(() => {
+        registerSession();
+    }, []);
+    const signOut = useCallback(() => {
+        authClient.signOut().then(() => {
+            posthog.reset();
+            posthog.opt_in_capturing();
+            setSession(null);
+        });
+    }, [posthog]);
+    // Show loading screen while checking authentication status
+    if (isLoading) {
+        return loader ? loader : "Loading...";
+    }
+    return (_jsx(authProviderContext.Provider, { value: { isLoading, data: session, signOut, registerSession }, children: children }));
+}

package/dist/src/modules/auth/hooks/useAuth.d.ts

@@ -0,0 +1,4 @@
+import { type AnyUseMutationOptions } from "@tanstack/react-query";
+export declare function useUpdateUser(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export declare function useUpdateUserPreferences<T extends Record<string, any>>(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+//# sourceMappingURL=useAuth.d.ts.map

package/dist/src/modules/auth/hooks/useAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../../../../src/modules/auth/hooks/useAuth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAe,MAAM,uBAAuB,CAAC;AAGhF,wBAAgB,aAAa,CAAC,OAAO,EAAE,qBAAqB,yEAM3D;AAED,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACpE,OAAO,EAAE,qBAAqB,yEAO/B"}

package/dist/src/modules/auth/hooks/useAuth.js

@@ -0,0 +1,14 @@
+import { useMutation } from "@tanstack/react-query";
+import { authClient } from "../auth.lib";
+export function useUpdateUser(options) {
+    return useMutation({
+        mutationFn: (...args) => authClient.updateUser(...args),
+        ...options,
+    });
+}
+export function useUpdateUserPreferences(options) {
+    return useMutation({
+        mutationFn: (preferences) => authClient.updateUser({ preferences: JSON.stringify(preferences) }),
+        ...options,
+    });
+}

package/dist/src/modules/auth/hooks/useAuthAdmin.d.ts

@@ -0,0 +1,21 @@
+import { type AnyUseMutationOptions } from "@tanstack/react-query";
+import { authClient } from "../auth.lib";
+type ListUsersArgs = Parameters<typeof authClient.admin.listUsers>;
+export declare function useInvalidateListUsers(...args: ListUsersArgs): () => Promise<void>;
+export declare function useListUsers(...args: ListUsersArgs): import("@tanstack/react-query").UseQueryResult<NonNullable<{
+    users: import("better-auth/plugins").UserWithRole[];
+    total: number;
+    limit: number | undefined;
+    offset: number | undefined;
+} | {
+    users: never[];
+    total: number;
+}>, Error>;
+export declare function useRemoveUser(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export declare function useUpdateUser(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export declare function useBanUser(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export declare function useUnbanUser(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export declare function useImpersonateUser(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export declare function useStopImpersonating(options: AnyUseMutationOptions): import("@tanstack/react-query").UseMutationResult<any, any, any, any>;
+export {};
+//# sourceMappingURL=useAuthAdmin.d.ts.map

package/dist/src/modules/auth/hooks/useAuthAdmin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthAdmin.d.ts","sourceRoot":"","sources":["../../../../../src/modules/auth/hooks/useAuthAdmin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAI3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AASzC,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AA4EnE,wBAAgB,sBAAsB,CAAC,GAAG,IAAI,EAAE,aAAa,uBAG5D;AAoCD,wBAAgB,YAAY,CAAC,GAAG,IAAI,EAAE,aAAa;;;;;;;;WAUlD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,qBAAqB,yEAM3D;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,qBAAqB,yEAM3D;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,qBAAqB,yEAMxD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,qBAAqB,yEAM1D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,qBAAqB,yEAMhE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,yEAKlE"}

package/dist/src/modules/auth/hooks/useAuthAdmin.js

@@ -0,0 +1,160 @@
+import { useMutation, useQuery, useQueryClient, } from "@tanstack/react-query";
+import { authClient } from "../auth.lib";
+/*
+type ListUsersParams = Parameters<typeof authClient.admin.listUsers>;
+type ListUsersArgs = Record<string, unknown>;
+
+type FilterOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
+
+type BetterAuthFilterParams = {
+  filterField: string;
+  filterValue: string | number | boolean;
+  filterOperator: FilterOperator;
+};
+
+export const authFilterMethods: FilterMethods = {
+  string: [{ value: "equals", label: "Equals", component: "text" }],
+  number: [
+    { value: "equals", label: "Equals", component: "number" },
+    { value: "greater_than", label: "Greater Than", component: "number" },
+    { value: "less_than", label: "Less Than", component: "number" },
+  ],
+  date: [
+    { value: "on", label: "On", component: "date" },
+    { value: "before", label: "Before", component: "date" },
+    { value: "after", label: "After", component: "date" },
+  ],
+  boolean: [{ value: "equals", label: "Equals", component: "radio" }],
+  enum: [{ value: "equals", label: "Equals", component: "select" }],
+};
+
+const baseMethodOperatorMap: Partial<Record<FilterMethodName, FilterOperator>> = {
+  equals: "eq",
+  greater_than: "gt",
+  less_than: "lt",
+  before: "lte",
+  after: "gte",
+  on: "eq",
+};
+
+const getAllowedMethods = (): Record<FilterMethodName, FilterOperator> => {
+  const operatorMap: Partial<Record<FilterMethodName, FilterOperator>> = {};
+  Object.values(authFilterMethods).forEach((methodsForType) => {
+    methodsForType.forEach((method: FilterMethod) => {
+      const operator = baseMethodOperatorMap[method.value];
+      if (operator) {
+        operatorMap[method.value] = operator;
+      }
+    });
+  });
+  return operatorMap as Record<FilterMethodName, FilterOperator>;
+};
+
+const filterMethodToOperatorMap = getAllowedMethods();
+
+const mapFilterToBetterAuth = (filter?: QueryFilter): Partial<BetterAuthFilterParams> => {
+  if (!filter) return {};
+  if (!filter.type) return {};
+  const allowedMethodsForType = authFilterMethods[filter.type]?.map((method) => method.value) ?? [];
+  if (!allowedMethodsForType.includes(filter.method)) return {};
+  const operator = filterMethodToOperatorMap[filter.method];
+  if (!operator) return {};
+  const { columnId, value, type } = filter;
+  if (value === undefined || value === null) return {};
+  if (type === "boolean" && typeof value === "boolean" && operator === "eq") {
+    return { filterField: columnId, filterValue: value, filterOperator: operator };
+  }
+  if (type === "number" && typeof value === "number") {
+    return { filterField: columnId, filterValue: value, filterOperator: operator };
+  }
+  if ((type === "string" || type === "enum" || type === "date") && typeof value === "string") {
+    return { filterField: columnId, filterValue: value, filterOperator: operator };
+  }
+  return {};
+};
+*/
+export function useInvalidateListUsers(...args) {
+    const queryClient = useQueryClient();
+    return () => queryClient.invalidateQueries({ queryKey: ["auth-admin-list-users", ...args] });
+}
+/*
+export function getListUsers(input: ListUsersArgs): any {
+  const {
+    filters,
+    page,
+    limit,
+    sort,
+    order,
+    ...listUsersParams
+  } = input as ListUsersArgs & QueryInput;
+  const filterParams = mapFilterToBetterAuth(filters?.[0]);
+  const sortDirection: "asc" | "desc" = order === "asc" ? "asc" : "desc";
+  const queryPayload = {
+    ...listUsersParams,
+    limit,
+    sortBy: sort,
+    sortDirection,
+    offset: (page - 1) * limit,
+    ...filterParams,
+  };
+
+  return {
+    queryKey: ["auth-admin-list-users", input],
+    queryFn: async () => {
+      const { data, error } = await authClient.admin.listUsers({
+        query: queryPayload,
+      });
+      if (error) return Promise.reject(error);
+      return data;
+    },
+  };
+}
+*/
+export function useListUsers(...args) {
+    return useQuery({
+        queryKey: ["auth-admin-list-users", ...args],
+        queryFn: async ({ queryKey }) => {
+            const listUserArgs = queryKey.slice(1);
+            const { data, error } = await authClient.admin.listUsers(...listUserArgs);
+            if (error)
+                return Promise.reject(error);
+            return data;
+        },
+    });
+}
+export function useRemoveUser(options) {
+    return useMutation({
+        mutationFn: (...args) => authClient.admin.removeUser(...args),
+        ...options,
+    });
+}
+export function useUpdateUser(options) {
+    return useMutation({
+        mutationFn: (...args) => authClient.admin.updateUser(...args),
+        ...options,
+    });
+}
+export function useBanUser(options) {
+    return useMutation({
+        mutationFn: (...args) => authClient.admin.banUser(...args),
+        ...options,
+    });
+}
+export function useUnbanUser(options) {
+    return useMutation({
+        mutationFn: (...args) => authClient.admin.unbanUser(...args),
+        ...options,
+    });
+}
+export function useImpersonateUser(options) {
+    return useMutation({
+        mutationFn: (...args) => authClient.admin.impersonateUser(...args),
+        ...options,
+    });
+}
+export function useStopImpersonating(options) {
+    return useMutation({
+        mutationFn: () => authClient.admin.stopImpersonating(),
+        ...options,
+    });
+}

package/dist/src/modules/auth/hooks/useSession.d.ts

@@ -0,0 +1,38 @@
+export declare function useSession(): {
+    isLoading: boolean;
+    data: ({
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+            banned: boolean | null | undefined;
+            role?: string | null | undefined;
+            banReason?: string | null | undefined;
+            banExpires?: Date | null | undefined;
+            stripeCustomerId?: string | null | undefined;
+            preferences?: string | null | undefined;
+            onboarding?: number | null | undefined;
+            flags?: string | null | undefined;
+        };
+        session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+            activeOrganizationId?: string | null | undefined;
+            activeTeamId?: string | null | undefined;
+            impersonatedBy?: string | null | undefined;
+        };
+    } | null) | null;
+    signOut: () => void;
+    registerSession: (onSuccess: () => void) => void;
+};
+//# sourceMappingURL=useSession.d.ts.map

package/dist/src/modules/auth/hooks/useSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSession.d.ts","sourceRoot":"","sources":["../../../../../src/modules/auth/hooks/useSession.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzB"}

package/dist/src/modules/auth/hooks/useSession.js

@@ -0,0 +1,5 @@
+import { useContext } from "react";
+import { authProviderContext } from "../components/AuthProvider";
+export function useSession() {
+    return useContext(authProviderContext);
+}

package/dist/src/modules/billing/components/BillingProvider.d.ts

@@ -0,0 +1,14 @@
+import type { BillingSchema } from "@m5kdev/commons/modules/billing/billing.schema";
+import type { UseBackendTRPC } from "#types";
+export declare const billingProviderContext: import("react").Context<{
+    isLoading: boolean;
+    data: BillingSchema | null;
+}>;
+export declare function BillingProvider({ useTRPC, children, loader, planPage, skipPlanCheck, }: {
+    useTRPC: UseBackendTRPC;
+    children: React.ReactNode;
+    loader?: React.ReactNode;
+    planPage: React.ReactNode;
+    skipPlanCheck?: boolean;
+}): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+//# sourceMappingURL=BillingProvider.d.ts.map

package/dist/src/modules/billing/components/BillingProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BillingProvider.d.ts","sourceRoot":"","sources":["../../../../../src/modules/billing/components/BillingProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAGpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAE7C,eAAO,MAAM,sBAAsB;eACtB,OAAO;UACZ,aAAa,GAAG,IAAI;EAI1B,CAAC;AAEH,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,aAAqB,GACtB,EAAE;IACD,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,2WAgCA"}

package/dist/src/modules/billing/components/BillingProvider.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+import { createContext } from "react";
+export const billingProviderContext = createContext({
+    isLoading: true,
+    data: null,
+});
+export function BillingProvider({ useTRPC, children, loader, planPage, skipPlanCheck = false, }) {
+    const trpc = useTRPC();
+    const { data: activeSubscription, isLoading } = useQuery(trpc.billing.getActiveSubscription.queryOptions(undefined, {
+        staleTime: 1000 * 60 * 60 * 4, // 4 hours
+        enabled: !skipPlanCheck,
+    }));
+    if (skipPlanCheck) {
+        return (_jsx(billingProviderContext.Provider, { value: { isLoading: false, data: null }, children: children }));
+    }
+    // Show loading screen while checking subscription status
+    if (isLoading) {
+        return loader ? loader : "Loading...";
+    }
+    if (!activeSubscription) {
+        return planPage;
+    }
+    return (_jsx(billingProviderContext.Provider, { value: { isLoading, data: activeSubscription ?? null }, children: children }));
+}

package/dist/src/modules/billing/hooks/useSubscription.d.ts

@@ -0,0 +1,5 @@
+export declare function useSubscription(): {
+    isLoading: boolean;
+    data: import("@m5kdev/commons/modules/billing/billing.schema").BillingSchema | null;
+};
+//# sourceMappingURL=useSubscription.d.ts.map

package/dist/src/modules/billing/hooks/useSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscription.d.ts","sourceRoot":"","sources":["../../../../../src/modules/billing/hooks/useSubscription.ts"],"names":[],"mappings":"AAGA,wBAAgB,eAAe;;;EAE9B"}

package/dist/src/modules/billing/hooks/useSubscription.js

@@ -0,0 +1,5 @@
+import { useContext } from "react";
+import { billingProviderContext } from "../components/BillingProvider";
+export function useSubscription() {
+    return useContext(billingProviderContext);
+}

package/dist/src/modules/file/hooks/useS3DownloadUrl.d.ts

@@ -0,0 +1,3 @@
+export declare function fetchS3DownloadUrl(filePath: string, serverUrl?: any): Promise<string>;
+export declare function useS3DownloadUrl(filePath: string, serverUrl?: any): import("@tanstack/react-query").UseQueryResult<string, Error>;
+//# sourceMappingURL=useS3DownloadUrl.d.ts.map

package/dist/src/modules/file/hooks/useS3DownloadUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useS3DownloadUrl.d.ts","sourceRoot":"","sources":["../../../../../src/modules/file/hooks/useS3DownloadUrl.ts"],"names":[],"mappings":"AAEA,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,SAAS,MAAkC,mBAK5C;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,MAAkC,iEAM7F"}

package/dist/src/modules/file/hooks/useS3DownloadUrl.js

@@ -0,0 +1,14 @@
+import { useQuery } from "@tanstack/react-query";
+export async function fetchS3DownloadUrl(filePath, serverUrl = import.meta.env.VITE_SERVER_URL) {
+    const res = await fetch(`${serverUrl}/upload/files/${filePath}`);
+    if (!res.ok)
+        throw new Error("Failed to get download URL");
+    return (await res.json()).url;
+}
+export function useS3DownloadUrl(filePath, serverUrl = import.meta.env.VITE_SERVER_URL) {
+    return useQuery({
+        queryKey: ["s3DownloadUrl", filePath],
+        queryFn: () => fetchS3DownloadUrl(filePath, serverUrl),
+        enabled: Boolean(filePath),
+    });
+}

package/dist/src/modules/file/hooks/useS3Upload.d.ts

@@ -0,0 +1,10 @@
+export type S3UploadStatus = "idle" | "uploading" | "success" | "error";
+export declare function useS3Upload(serverUrl?: string): {
+    upload: (file: File | Blob, prefix?: string) => Promise<string>;
+    progress: number;
+    status: S3UploadStatus;
+    error: string | null;
+    uploadedUrl: string | null;
+    reset: () => void;
+};
+//# sourceMappingURL=useS3Upload.d.ts.map

package/dist/src/modules/file/hooks/useS3Upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useS3Upload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/file/hooks/useS3Upload.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAiBxE,wBAAgB,WAAW,CAAC,SAAS,SAAK;mBAMA,IAAI,GAAG,IAAI,WAAW,MAAM;;;;;;EA+DrE"}

package/dist/src/modules/file/hooks/useS3Upload.js

@@ -0,0 +1,76 @@
+import { useCallback, useState } from "react";
+async function getPresignedUrl(filename, filetype, serverUrl = "") {
+    const res = await fetch(`${serverUrl}/upload/s3-presigned-url`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ filename, filetype }),
+    });
+    if (!res.ok)
+        throw new Error("Failed to get presigned URL");
+    const data = (await res.json());
+    return data.url;
+}
+export function useS3Upload(serverUrl = "") {
+    const [progress, setProgress] = useState(0);
+    const [status, setStatus] = useState("idle");
+    const [error, setError] = useState(null);
+    const [uploadedUrl, setUploadedUrl] = useState(null);
+    const upload = useCallback(async (file, prefix) => {
+        setProgress(0);
+        setStatus("uploading");
+        setError(null);
+        setUploadedUrl(null);
+        try {
+            const originalFilename = file instanceof File ? file.name : `upload-${Date.now()}`;
+            const extension = originalFilename.split(".").pop() || "";
+            const uuid = crypto.randomUUID();
+            const filename = prefix
+                ? `${prefix}/${uuid}.${extension}`
+                : `${uuid}.${extension}`;
+            const filetype = file instanceof File ? file.type : "application/octet-stream";
+            const presignedUrl = await getPresignedUrl(filename, filetype, serverUrl);
+            return await new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open("PUT", presignedUrl);
+                xhr.setRequestHeader("Content-Type", filetype);
+                xhr.upload.onprogress = (event) => {
+                    if (event.lengthComputable) {
+                        setProgress(Math.round((event.loaded * 100) / event.total));
+                    }
+                };
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        setProgress(100);
+                        setStatus("success");
+                        // Remove query params to get the public URL
+                        setUploadedUrl(presignedUrl.split("?")[0]);
+                        resolve(filename);
+                    }
+                    else {
+                        setStatus("error");
+                        setError(`Upload failed with status ${xhr.status}`);
+                        reject(new Error(`Upload failed with status ${xhr.status}`));
+                    }
+                };
+                xhr.onerror = () => {
+                    setStatus("error");
+                    setError("Network error during upload");
+                    reject(new Error("Network error during upload"));
+                };
+                xhr.send(file);
+            });
+        }
+        catch (err) {
+            setStatus("error");
+            setError(err?.message || "Unknown error");
+            return Promise.reject(err);
+        }
+    }, [serverUrl]);
+    const reset = useCallback(() => {
+        setProgress(0);
+        setStatus("idle");
+        setError(null);
+        setUploadedUrl(null);
+    }, []);
+    return { upload, progress, status, error, uploadedUrl, reset };
+}

package/dist/src/modules/file/hooks/useUpload.d.ts

@@ -0,0 +1,30 @@
+export type UploadStatus = "pending" | "uploading" | "completed" | "error";
+export interface UploadFileTask {
+    id: string;
+    file: File;
+    progress: number;
+    status: UploadStatus;
+    errorMessage?: string;
+    bytesUploaded: number;
+    totalBytes: number;
+}
+export declare function useFileUpload(): {
+    upload: <T>(type: string, file: File) => Promise<T>;
+    reset: () => void;
+    id?: string | undefined;
+    file?: File | undefined;
+    progress?: number | undefined;
+    status?: UploadStatus | undefined;
+    errorMessage?: string;
+    bytesUploaded?: number | undefined;
+    totalBytes?: number | undefined;
+};
+export declare function useMultipartUpload(): {
+    uploadQueue: UploadFileTask[];
+    overallProgress: number;
+    uploadFiles: (type: string, files: File[]) => Promise<void>;
+    reset: () => void;
+    getTotalBytes: () => number;
+    getTotalBytesUploaded: () => number;
+};
+//# sourceMappingURL=useUpload.d.ts.map

package/dist/src/modules/file/hooks/useUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/file/hooks/useUpload.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,OAAO,CAAC;AAE3E,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAmED,wBAAgB,aAAa;aAGO,CAAC,QAAQ,MAAM,QAAQ,IAAI,KAAG,OAAO,CAAC,CAAC,CAAC;;;;;;mBAzE3D,MAAM;;;EAuHtB;AAGD,wBAAgB,kBAAkB;;;wBA6DjB,MAAM,SAAS,IAAI,EAAE;;;;EA2BrC"}