@sudobility/wildduck_client 0.0.14

package/dist/hooks/users/useWildduckGetUser.d.ts

@@ -0,0 +1,397 @@
+import { type NetworkClient } from "@sudobility/di";
+import { type WildduckConfig } from "@sudobility/types";
+import type { WildduckUserAuth } from "@sudobility/types";
+export interface UseWildduckGetUserParams {
+    userAuth?: WildduckUserAuth;
+    devMode?: boolean;
+}
+export declare const useWildduckGetUser: (networkClient: NetworkClient, config: WildduckConfig, params?: UseWildduckGetUserParams) => {
+    data: import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }>;
+} | {
+    data: import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }>;
+} | {
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }>;
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }>;
+} | {
+    data: import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<import("@sudobility/types").WildduckUserResponse | {
+        success: boolean;
+        id: string;
+        username: string;
+        name: string;
+        address: string;
+        quota: {
+            allowed: number;
+            used: number;
+        };
+        hasPasswordSet: boolean;
+        activated: boolean;
+        disabled: boolean;
+        suspended: boolean;
+        error: null;
+    }>;
+};
+export type UseWildduckGetUserReturn = ReturnType<typeof useWildduckGetUser>;
+//# sourceMappingURL=useWildduckGetUser.d.ts.map

package/dist/hooks/users/useWildduckGetUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckGetUser.d.ts","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckGetUser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAWD,eAAO,MAAM,kBAAkB,GAC7B,eAAe,aAAa,EAC5B,QAAQ,cAAc,EACtB,SAAQ,wBAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDtC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/hooks/users/useWildduckGetUser.js

@@ -0,0 +1,45 @@
+import { useCallback, useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { WildduckAPI } from "../../network/wildduck-client";
+export const useWildduckGetUser = (networkClient, config, params = {}) => {
+    const { userAuth, devMode = false } = params;
+    const api = useMemo(() => new WildduckAPI(networkClient, config), [networkClient, config]);
+    const queryFn = useCallback(async () => {
+        if (!userAuth)
+            throw new Error("userAuth is required");
+        try {
+            return await api.getUser(userAuth);
+        }
+        catch (err) {
+            if (devMode) {
+                console.warn("[DevMode] getUser failed, returning mock data:", err);
+                return {
+                    success: true,
+                    id: userAuth.userId,
+                    username: `${userAuth.userId}@example.com`,
+                    name: `Mock User ${userAuth.userId}`,
+                    address: `${userAuth.userId}@example.com`,
+                    quota: {
+                        allowed: 1073741824,
+                        used: 134217728,
+                    },
+                    hasPasswordSet: false,
+                    activated: true,
+                    disabled: false,
+                    suspended: false,
+                    error: null,
+                };
+            }
+            throw err;
+        }
+    }, [userAuth, api, devMode]);
+    const query = useQuery({
+        queryKey: ["wildduck-user", userAuth?.userId],
+        queryFn,
+        enabled: !!userAuth,
+    });
+    return useMemo(() => ({
+        ...query,
+    }), [query]);
+};
+//# sourceMappingURL=useWildduckGetUser.js.map

package/dist/hooks/users/useWildduckGetUser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckGetUser.js","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckGetUser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAmB5D,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,aAA4B,EAC5B,MAAsB,EACtB,SAAmC,EAAE,EACrC,EAAE;IACF,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC;IAE7C,MAAM,GAAG,GAAG,OAAO,CACjB,GAAG,EAAE,CAAC,IAAI,WAAW,CAAC,aAAa,EAAE,MAAM,CAAC,EAC5C,CAAC,aAAa,EAAE,MAAM,CAAC,CACxB,CAAC;IAEF,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;QACrC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAEvD,IAAI,CAAC;YACH,OAAO,MAAM,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,IAAI,CAAC,gDAAgD,EAAE,GAAG,CAAC,CAAC;gBACpE,OAAO;oBACL,OAAO,EAAE,IAAI;oBACb,EAAE,EAAE,QAAQ,CAAC,MAAM;oBACnB,QAAQ,EAAE,GAAG,QAAQ,CAAC,MAAM,cAAc;oBAC1C,IAAI,EAAE,aAAa,QAAQ,CAAC,MAAM,EAAE;oBACpC,OAAO,EAAE,GAAG,QAAQ,CAAC,MAAM,cAAc;oBACzC,KAAK,EAAE;wBACL,OAAO,EAAE,UAAU;wBACnB,IAAI,EAAE,SAAS;qBAChB;oBACD,cAAc,EAAE,KAAK;oBACrB,SAAS,EAAE,IAAI;oBACf,QAAQ,EAAE,KAAK;oBACf,SAAS,EAAE,KAAK;oBAChB,KAAK,EAAE,IAAI;iBACZ,CAAC;YACJ,CAAC;YACD,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC;IAE7B,MAAM,KAAK,GAAG,QAAQ,CAAC;QACrB,QAAQ,EAAE,CAAC,eAAe,EAAE,QAAQ,EAAE,MAAM,CAAC;QAC7C,OAAO;QACP,OAAO,EAAE,CAAC,CAAC,QAAQ;KACpB,CAAC,CAAC;IAEH,OAAO,OAAO,CACZ,GAAG,EAAE,CAAC,CAAC;QACL,GAAG,KAAK;KACT,CAAC,EACF,CAAC,KAAK,CAAC,CACR,CAAC;AACJ,CAAC,CAAC"}

package/dist/hooks/users/useWildduckUpdateUser.d.ts

@@ -0,0 +1,13 @@
+import type { Optional } from "@sudobility/types";
+import { type NetworkClient } from "@sudobility/di";
+import { type WildduckConfig } from "@sudobility/types";
+import type { WildduckSuccessResponse, WildduckUpdateUserRequest, WildduckUserAuth } from "@sudobility/types";
+interface UseUpdateUserReturn {
+    updateUser: (userAuth: WildduckUserAuth, params: WildduckUpdateUserRequest) => Promise<WildduckSuccessResponse>;
+    isLoading: boolean;
+    error: Optional<Error>;
+    clearError: () => void;
+}
+export declare const useWildduckUpdateUser: (networkClient: NetworkClient, config: WildduckConfig, devMode?: boolean) => UseUpdateUserReturn;
+export {};
+//# sourceMappingURL=useWildduckUpdateUser.d.ts.map

package/dist/hooks/users/useWildduckUpdateUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckUpdateUser.d.ts","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckUpdateUser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EACzB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAE3B,UAAU,mBAAmB;IAC3B,UAAU,EAAE,CACV,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,yBAAyB,KAC9B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IACvB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAYD,eAAO,MAAM,qBAAqB,GAChC,eAAe,aAAa,EAC5B,QAAQ,cAAc,EACtB,UAAS,OAAe,KACvB,mBAiEF,CAAC"}

package/dist/hooks/users/useWildduckUpdateUser.js

@@ -0,0 +1,44 @@
+import { useCallback, useMemo } from "react";
+import { WildduckAPI } from "../../network/wildduck-client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+export const useWildduckUpdateUser = (networkClient, config, devMode = false) => {
+    const queryClient = useQueryClient();
+    const wildduckClient = useMemo(() => new WildduckAPI(networkClient, config), [networkClient, config]);
+    const updateMutation = useMutation({
+        mutationKey: [
+            "wildduck-update-user",
+            config.cloudflareWorkerUrl || config.backendUrl,
+        ],
+        mutationFn: async ({ userAuth, params, }) => {
+            try {
+                return await wildduckClient.updateUser(userAuth, params);
+            }
+            catch (err) {
+                if (devMode) {
+                    console.warn("[DevMode] updateUser failed, returning mock data:", err);
+                    return { success: true };
+                }
+                throw err;
+            }
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({
+                queryKey: ["wildduck-user", variables.userAuth.userId],
+            });
+            queryClient.invalidateQueries({
+                queryKey: ["wildduck-users"],
+            });
+        },
+    });
+    const updateUser = useCallback(async (userAuth, params) => {
+        return updateMutation.mutateAsync({ userAuth, params });
+    }, [updateMutation]);
+    const clearError = useCallback(() => updateMutation.reset(), [updateMutation]);
+    return useMemo(() => ({
+        updateUser,
+        isLoading: updateMutation.isPending,
+        error: updateMutation.error,
+        clearError,
+    }), [updateUser, updateMutation.isPending, updateMutation.error, clearError]);
+};
+//# sourceMappingURL=useWildduckUpdateUser.js.map

package/dist/hooks/users/useWildduckUpdateUser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckUpdateUser.js","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckUpdateUser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AA2BpE,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,aAA4B,EAC5B,MAAsB,EACtB,UAAmB,KAAK,EACH,EAAE;IACvB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IAErC,MAAM,cAAc,GAAG,OAAO,CAC5B,GAAG,EAAE,CAAC,IAAI,WAAW,CAAC,aAAa,EAAE,MAAM,CAAC,EAC5C,CAAC,aAAa,EAAE,MAAM,CAAC,CACxB,CAAC;IAEF,MAAM,cAAc,GAAG,WAAW,CAAC;QACjC,WAAW,EAAE;YACX,sBAAsB;YACtB,MAAM,CAAC,mBAAmB,IAAI,MAAM,CAAC,UAAU;SAChD;QACD,UAAU,EAAE,KAAK,EAAE,EACjB,QAAQ,EACR,MAAM,GAIP,EAAoC,EAAE;YACrC,IAAI,CAAC;gBACH,OAAO,MAAM,cAAc,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC3D,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,OAAO,EAAE,CAAC;oBACZ,OAAO,CAAC,IAAI,CACV,mDAAmD,EACnD,GAAG,CACJ,CAAC;oBACF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;gBAC3B,CAAC;gBACD,MAAM,GAAG,CAAC;YACZ,CAAC;QACH,CAAC;QACD,SAAS,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE;YAE1B,WAAW,CAAC,iBAAiB,CAAC;gBAC5B,QAAQ,EAAE,CAAC,eAAe,EAAE,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC;aACvD,CAAC,CAAC;YACH,WAAW,CAAC,iBAAiB,CAAC;gBAC5B,QAAQ,EAAE,CAAC,gBAAgB,CAAC;aAC7B,CAAC,CAAC;QACL,CAAC;KACF,CAAC,CAAC;IAEH,MAAM,UAAU,GAAG,WAAW,CAC5B,KAAK,EAAE,QAA0B,EAAE,MAAiC,EAAE,EAAE;QACtE,OAAO,cAAc,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC,EACD,CAAC,cAAc,CAAC,CACjB,CAAC;IAEF,MAAM,UAAU,GAAG,WAAW,CAC5B,GAAG,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,EAC5B,CAAC,cAAc,CAAC,CACjB,CAAC;IAEF,OAAO,OAAO,CACZ,GAAG,EAAE,CAAC,CAAC;QACL,UAAU;QACV,SAAS,EAAE,cAAc,CAAC,SAAS;QACnC,KAAK,EAAE,cAAc,CAAC,KAAK;QAC3B,UAAU;KACX,CAAC,EACF,CAAC,UAAU,EAAE,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,CACzE,CAAC;AACJ,CAAC,CAAC"}

package/dist/hooks/users/useWildduckUser2FA.d.ts

@@ -0,0 +1,25 @@
+import type { WildduckAPI } from "../../network/wildduck-client";
+import type { WildduckUserAuth } from "@sudobility/types";
+export interface TwoFASettings {
+    enabled2fa: string[];
+}
+export interface DisableTwoFAParams {
+    userAuth: WildduckUserAuth;
+}
+export declare const useWildduckUser2FA: (api: WildduckAPI, userAuth?: WildduckUserAuth) => {
+    twoFA: TwoFASettings | undefined;
+    enabled2fa: string[];
+    isEnabled: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    hasMethod: (method: string) => boolean;
+    hasTOTP: boolean;
+    hasU2F: boolean;
+    hasWebAuthn: boolean;
+    disable2FA: import("@tanstack/react-query").UseMutateFunction<import("@sudobility/types").WildduckSuccessResponse, Error, DisableTwoFAParams, unknown>;
+    disable2FAAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@sudobility/types").WildduckSuccessResponse, Error, DisableTwoFAParams, unknown>;
+    isDisabling: boolean;
+    disableError: Error | null;
+};
+//# sourceMappingURL=useWildduckUser2FA.d.ts.map

package/dist/hooks/users/useWildduckUser2FA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckUser2FA.d.ts","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckUser2FA.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,mBAAmB,CAAC;AAEhF,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAUD,eAAO,MAAM,kBAAkB,GAC7B,KAAK,WAAW,EAChB,WAAW,gBAAgB;;;;;;;wBA4ChB,MAAM,KAAG,OAAO;;;;;;;;CAsD5B,CAAC"}

package/dist/hooks/users/useWildduckUser2FA.js

@@ -0,0 +1,70 @@
+import { useCallback, useMemo } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+export const useWildduckUser2FA = (api, userAuth) => {
+    const queryClient = useQueryClient();
+    const userId = userAuth?.userId;
+    const twoFAQueryFn = useCallback(async () => {
+        if (!userAuth)
+            throw new Error("User auth is required");
+        const user = (await api.getUser(userAuth));
+        return {
+            enabled2fa: user.enabled2fa || [],
+        };
+    }, [userAuth, api]);
+    const twoFAQuery = useQuery({
+        queryKey: ["user", userId, "2fa"],
+        queryFn: twoFAQueryFn,
+        enabled: !!userAuth,
+    });
+    const disable2FA = useMutation({
+        mutationFn: async ({ userAuth }) => {
+            return await api.updateUser(userAuth, { disable2fa: true });
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({
+                queryKey: ["user", variables.userAuth.userId],
+            });
+            queryClient.invalidateQueries({
+                queryKey: ["user", variables.userAuth.userId, "2fa"],
+            });
+        },
+    });
+    const isEnabled = (twoFAQuery.data?.enabled2fa?.length ?? 0) > 0;
+    const hasMethod = useCallback((method) => {
+        return twoFAQuery.data?.enabled2fa?.includes(method) ?? false;
+    }, [twoFAQuery.data?.enabled2fa]);
+    const hasTOTP = hasMethod("totp");
+    const hasU2F = hasMethod("u2f");
+    const hasWebAuthn = hasMethod("webauthn");
+    return useMemo(() => ({
+        twoFA: twoFAQuery.data,
+        enabled2fa: twoFAQuery.data?.enabled2fa || [],
+        isEnabled,
+        isLoading: twoFAQuery.isLoading,
+        isError: twoFAQuery.isError,
+        error: twoFAQuery.error,
+        hasMethod,
+        hasTOTP,
+        hasU2F,
+        hasWebAuthn,
+        disable2FA: disable2FA.mutate,
+        disable2FAAsync: disable2FA.mutateAsync,
+        isDisabling: disable2FA.isPending,
+        disableError: disable2FA.error,
+    }), [
+        twoFAQuery.data,
+        isEnabled,
+        twoFAQuery.isLoading,
+        twoFAQuery.isError,
+        twoFAQuery.error,
+        hasMethod,
+        hasTOTP,
+        hasU2F,
+        hasWebAuthn,
+        disable2FA.mutate,
+        disable2FA.mutateAsync,
+        disable2FA.isPending,
+        disable2FA.error,
+    ]);
+};
+//# sourceMappingURL=useWildduckUser2FA.js.map

package/dist/hooks/users/useWildduckUser2FA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckUser2FA.js","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckUser2FA.ts"],"names":[],"mappings":"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"}

package/dist/hooks/users/useWildduckUserEncryption.d.ts

@@ -0,0 +1,40 @@
+import type { WildduckAPI } from "../../network/wildduck-client";
+import type { WildduckKeyInfo, WildduckUserAuth } from "@sudobility/types";
+export interface EncryptionSettings {
+    encryptMessages: boolean;
+    encryptForwarded: boolean;
+    pubKey: string;
+    keyInfo?: WildduckKeyInfo;
+}
+export interface UpdateEncryptionParams {
+    userAuth: WildduckUserAuth;
+    encryptMessages?: boolean;
+    encryptForwarded?: boolean;
+    pubKey?: string;
+}
+export declare const useWildduckUserEncryption: (api: WildduckAPI, userAuth?: WildduckUserAuth) => {
+    encryption: EncryptionSettings | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    encryptMessages: boolean | undefined;
+    encryptForwarded: boolean | undefined;
+    pubKey: string | undefined;
+    keyInfo: WildduckKeyInfo | undefined;
+    updateEncryption: import("@tanstack/react-query").UseMutateFunction<import("@sudobility/types").WildduckSuccessResponse, Error, UpdateEncryptionParams, unknown>;
+    updateEncryptionAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@sudobility/types").WildduckSuccessResponse, Error, UpdateEncryptionParams, unknown>;
+    isUpdating: boolean;
+    updatePubKey: import("@tanstack/react-query").UseMutateFunction<import("@sudobility/types").WildduckSuccessResponse, Error, {
+        userAuth: WildduckUserAuth;
+        pubKey: string;
+    }, unknown>;
+    updatePubKeyAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@sudobility/types").WildduckSuccessResponse, Error, {
+        userAuth: WildduckUserAuth;
+        pubKey: string;
+    }, unknown>;
+    isUpdatingKey: boolean;
+    removePubKey: import("@tanstack/react-query").UseMutateFunction<import("@sudobility/types").WildduckSuccessResponse, Error, WildduckUserAuth, unknown>;
+    removePubKeyAsync: import("@tanstack/react-query").UseMutateAsyncFunction<import("@sudobility/types").WildduckSuccessResponse, Error, WildduckUserAuth, unknown>;
+    isRemovingKey: boolean;
+};
+//# sourceMappingURL=useWildduckUserEncryption.d.ts.map

package/dist/hooks/users/useWildduckUserEncryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWildduckUserEncryption.d.ts","sourceRoot":"","sources":["../../../src/hooks/users/useWildduckUserEncryption.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD,eAAO,MAAM,yBAAyB,GACpC,KAAK,WAAW,EAChB,WAAW,gBAAgB;;;;;;;;;;;;;kBAiDb,gBAAgB;gBAClB,MAAM;;;kBADJ,gBAAgB;gBAClB,MAAM;;;;;;CAsEnB,CAAC"}