@vitnode/core 0.0.1-canary.0

package/dist/src/views/auth/settings/devices/devices-list-skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices-list-skeleton.d.ts","sourceRoot":"","sources":["../../../../../../src/views/auth/settings/devices/devices-list-skeleton.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB,mCAsB/B,CAAC"}

package/dist/src/views/auth/settings/devices/devices-list-skeleton.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{Separator}from"../../../../components/ui/separator.js";import{Skeleton}from"../../../../components/ui/skeleton.js";const DETAIL_IDS=Array.from({length:3},(_,i)=>`s-detail-${i}`);export const DevicesListSkeleton=()=>_jsxs("div",{"aria-hidden":true,className:"rounded-lg border p-4 sm:p-6",children:[_jsxs("div",{className:"flex items-start gap-4",children:[_jsx(Skeleton,{className:"size-10 shrink-0 rounded-md"}),_jsxs("div",{className:"min-w-0 flex-1 space-y-1",children:[_jsx(Skeleton,{className:"h-6 w-40"}),_jsx(Skeleton,{className:"h-5 w-32"})]})]}),_jsx(Separator,{className:"my-4"}),_jsx("div",{className:"grid gap-2",children:DETAIL_IDS.map(id=>_jsxs("div",{className:"grid gap-1 sm:grid-cols-[10rem_1fr]",children:[_jsx(Skeleton,{className:"h-5 w-24"}),_jsx(Skeleton,{className:"h-5 w-48"})]},id))})]});

package/dist/src/views/auth/settings/devices/devices-query.d.ts

@@ -0,0 +1,543 @@
+export declare const usersModuleRef: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "users", [import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/session";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        ai: import("zod").ZodObject<{
+                            models: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                model: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                        user: import("zod").ZodNullable<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            email: import("zod").ZodString;
+                            name: import("zod").ZodString;
+                            nameCode: import("zod").ZodString;
+                            createdAt: import("zod").ZodDate;
+                            newsletter: import("zod").ZodBoolean;
+                            avatarColor: import("zod").ZodString;
+                            emailVerified: import("zod").ZodBoolean;
+                            roleId: import("zod").ZodNumber;
+                            birthday: import("zod").ZodNullable<import("zod").ZodDate>;
+                            isAdmin: import("zod").ZodBoolean;
+                            isModerator: import("zod").ZodBoolean;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/sign_in";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        email: import("zod").ZodEmail;
+                        password: import("zod").ZodString;
+                        isAdmin: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        403: {
+            description: string;
+        };
+        201: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        token: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/sign_out";
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        isAdmin: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/sign_up";
+    withCaptcha: true;
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        email: import("zod").ZodEmail;
+                        name: import("zod").ZodString;
+                        password: import("zod").ZodString;
+                        newsletter: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        emailVerified: import("zod").ZodBoolean;
+                        email: import("zod").ZodEmail;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/test";
+    responses: {
+        200: {
+            content: {
+                "text/plain": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+        201: {
+            content: {
+                "text/plain": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/reset-password";
+    withCaptcha: true;
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        email: import("zod").ZodEmail;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/change-password";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        password: import("zod").ZodString;
+                        userId: import("zod").ZodNumber;
+                        token: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/permissions";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        root: import("zod").ZodBoolean;
+                        permissions: import("zod").ZodArray<import("zod").ZodObject<{
+                            plugin: import("zod").ZodString;
+                            module: import("zod").ZodString;
+                            permission: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/devices";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        devices: import("zod").ZodArray<import("zod").ZodObject<{
+                            publicId: import("zod").ZodString;
+                            ipAddress: import("zod").ZodString;
+                            os: import("zod").ZodString;
+                            browser: import("zod").ZodString;
+                            deviceType: import("zod").ZodEnum<{
+                                desktop: "desktop";
+                                mobile: "mobile";
+                                tablet: "tablet";
+                            }>;
+                            lastSeen: import("zod").ZodDate;
+                            expiresAt: import("zod").ZodDate;
+                            isCurrent: import("zod").ZodBoolean;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/devices/{publicId}";
+    request: {
+        params: import("zod").ZodObject<{
+            publicId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], (import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "files", [import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            first: import("zod").ZodOptional<import("zod").ZodString>;
+            last: import("zod").ZodOptional<import("zod").ZodString>;
+            order: import("zod").ZodOptional<import("zod").ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                createdAt: "createdAt";
+                size: "size";
+                name: "name";
+            }>>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        edges: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            name: import("zod").ZodString;
+                            folder: import("zod").ZodString;
+                            mimeType: import("zod").ZodNullable<import("zod").ZodString>;
+                            size: import("zod").ZodNumber;
+                            metadata: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                            createdAt: import("zod").ZodDate;
+                            dimensions: import("zod").ZodNullable<import("zod").ZodObject<{
+                                width: import("zod").ZodNumber;
+                                height: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strip>>;
+                            url: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>>;
+                        pageInfo: import("zod").ZodObject<{
+                            totalCount: import("zod").ZodNumber;
+                            count: import("zod").ZodNumber;
+                            hasNextPage: import("zod").ZodBoolean;
+                            hasPreviousPage: import("zod").ZodBoolean;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}/download";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/octet-stream": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        query: import("zod").ZodObject<{
+            force: import("zod").ZodOptional<import("zod").ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        code: import("zod").ZodString;
+                        content: import("zod").ZodBoolean;
+                        id: import("zod").ZodNumber;
+                        revisions: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../../../api/lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]> | import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "sso", [import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{providerId}/callback";
+    request: {
+        params: import("zod").ZodObject<{
+            providerId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        query: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            state: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        token: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/{providerId}";
+    request: {
+        params: import("zod").ZodObject<{
+            providerId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        url: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../../../api/lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>)[]>;
+export declare const DEVICE_TYPES: readonly ["desktop", "tablet", "mobile"];
+export type DeviceType = (typeof DEVICE_TYPES)[number];
+export interface Device {
+    browser: string;
+    deviceType: DeviceType;
+    expiresAt: Date | string;
+    ipAddress: string;
+    isCurrent: boolean;
+    lastSeen: Date | string;
+    os: string;
+    publicId: string;
+}
+export interface DevicesApi {
+    devices: Device[];
+}
+export type DevicesFetcher = () => Promise<DevicesApi>;
+export declare class DevicesRequestError extends Error {
+    constructor(status: number);
+    readonly status: number;
+}
+export declare const isDevicesRequestError: (error: unknown) => error is DevicesRequestError;
+export declare const fetchDevicesInBrowser: DevicesFetcher;
+export declare const DEVICES_IDENTITY_ROOT: readonly ["devices", "user"];
+export declare const devicesQueryKey: (userId: number) => readonly ["devices", "user", number];
+export declare const devicesQueryOptions: ({ fetchDevices, userId, }: {
+    fetchDevices?: DevicesFetcher;
+    userId: number;
+}) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<DevicesApi, Error, DevicesApi, readonly ["devices", "user", number]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<DevicesApi, readonly ["devices", "user", number], never> | undefined;
+} & {
+    queryKey: readonly ["devices", "user", number] & {
+        [dataTagSymbol]: DevicesApi;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export type DevicesQueryOptions = ReturnType<typeof devicesQueryOptions>;
+//# sourceMappingURL=devices-query.d.ts.map

package/dist/src/views/auth/settings/devices/devices-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices-query.d.ts","sourceRoot":"","sources":["../../../../../../src/views/auth/settings/devices/devices-query.ts"],"names":[],"mappings":"AA2CA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sMAE1B,CAAC;AAGF,eAAO,MAAM,YAAY,0CAA2C,CAAC;AACrE,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAYvD,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAclB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB;AAGD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAeD,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;AAmCvD,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,MAAM,EAAE,MAAM;IAM1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,qBAAqB,GAChC,OAAO,OAAO,KACb,KAAK,IAAI,mBACoD,CAAC;AAUjE,eAAO,MAAM,qBAAqB,EAAE,cAUnC,CAAC;AAgBF,eAAO,MAAM,qBAAqB,8BAA+B,CAAC;AAyClE,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,yCACD,CAAC;AA4C9C,eAAO,MAAM,mBAAmB,GAAI,2BAGjC;IACD,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;CAChB;;;;;;;CASG,CAAC;AASL,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/src/views/auth/settings/devices/devices-query.js

@@ -0,0 +1 @@
+import{queryOptions}from"@tanstack/react-query";import{CONFIG_PLUGIN}from"../../../../config.js";import{clientModule,fetcherClient}from"../../../../lib/fetcher-client.js";import{RECORD_STALE_TIME}from"../../../../lib/query-freshness.js";export const usersModuleRef=clientModule(CONFIG_PLUGIN.pluginId);export const DEVICE_TYPES=["desktop","tablet","mobile"];const DEVICES_REQUEST_ERROR="DevicesRequestError";export class DevicesRequestError extends Error{constructor(status){super(`The devices API answered ${status} for the current user's devices.`);this.name=DEVICES_REQUEST_ERROR;this.status=status}status}export const isDevicesRequestError=error=>error instanceof Error&&error.name===DEVICES_REQUEST_ERROR;export const fetchDevicesInBrowser=async()=>{const response=await fetcherClient(usersModuleRef,{method:"get",module:"users",path:"/devices"});if(!response.ok)throw new DevicesRequestError(response.status);return await response.json()};export const DEVICES_IDENTITY_ROOT=["devices","user"];export const devicesQueryKey=userId=>[...DEVICES_IDENTITY_ROOT,userId];export const devicesQueryOptions=({fetchDevices=fetchDevicesInBrowser,userId})=>queryOptions({queryFn:async()=>await fetchDevices(),queryKey:devicesQueryKey(userId),retry:false,staleTime:RECORD_STALE_TIME});

package/dist/src/views/auth/settings/devices/devices-revoke.d.ts

@@ -0,0 +1,18 @@
+import type { Device } from "./devices-query";
+export interface RevokeDeviceArgs {
+    publicId: string;
+}
+export interface RevokeDeviceResult {
+    data?: true;
+    error?: {
+        status: number;
+    };
+}
+export type RevokeDevice = (args: RevokeDeviceArgs) => Promise<RevokeDeviceResult>;
+export declare const REVOKE_CURRENT_DEVICE_STATUS = 400;
+export declare const isRevokableDevice: (device: Pick<Device, "isCurrent">) => boolean;
+export declare const isDevicePublicId: (publicId: string) => boolean;
+export declare const revokeResultFromStatus: (status: number) => RevokeDeviceResult;
+export declare const revokeDeviceInBrowser: RevokeDevice;
+export declare const shouldRefreshAfterRevoke: ({ data, error, }: RevokeDeviceResult) => boolean;
+//# sourceMappingURL=devices-revoke.d.ts.map

package/dist/src/views/auth/settings/devices/devices-revoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices-revoke.d.ts","sourceRoot":"","sources":["../../../../../../src/views/auth/settings/devices/devices-revoke.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AA4C9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAWD,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,KAAK,CAAC,EAAE;QACN,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAQD,MAAM,MAAM,YAAY,GAAG,CACzB,IAAI,EAAE,gBAAgB,KACnB,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAYjC,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAUhD,eAAO,MAAM,iBAAiB,GAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,KAAG,OACnD,CAAC;AAoBpB,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,KAAG,OACnB,CAAC;AAiBlC,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,kBACC,CAAC;AAqB1D,eAAO,MAAM,qBAAqB,EAAE,YAgBnC,CAAC;AAsBF,eAAO,MAAM,wBAAwB,GAAI,kBAGtC,kBAAkB,KAAG,OAMvB,CAAC"}

package/dist/src/views/auth/settings/devices/devices-revoke.js

@@ -0,0 +1 @@
+import{fetcherClient}from"../../../../lib/fetcher-client.js";import{usersModuleRef}from"./devices-query.js";export const REVOKE_CURRENT_DEVICE_STATUS=400;export const isRevokableDevice=device=>!device.isCurrent;const DEVICE_PUBLIC_ID=/^[A-Za-z0-9_-]{1,128}$/;export const isDevicePublicId=publicId=>DEVICE_PUBLIC_ID.test(publicId);export const revokeResultFromStatus=status=>status===200?{data:true}:{error:{status}};export const revokeDeviceInBrowser=async({publicId})=>{if(!isDevicePublicId(publicId))return{error:{status:400}};try{const response=await fetcherClient(usersModuleRef,{args:{params:{publicId}},method:"delete",module:"users",options:{credentials:"include"},path:"/devices/{publicId}"});return revokeResultFromStatus(response.status)}catch{return{error:{status:500}}}};export const shouldRefreshAfterRevoke=({data,error})=>{if(data)return true;return error?.status===404||error?.status===REVOKE_CURRENT_DEVICE_STATUS};

package/dist/src/views/auth/settings/devices/revoke-device-button.d.ts

@@ -0,0 +1,7 @@
+import type { RevokeDevice } from "./devices-revoke";
+export declare const RevokeDeviceButton: ({ onRevoke, os, publicId, }: {
+    onRevoke: RevokeDevice;
+    os: string;
+    publicId: string;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=revoke-device-button.d.ts.map

package/dist/src/views/auth/settings/devices/revoke-device-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revoke-device-button.d.ts","sourceRoot":"","sources":["../../../../../../src/views/auth/settings/devices/revoke-device-button.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAwBrD,eAAO,MAAM,kBAAkB,GAAI,6BAIhC;IACD,QAAQ,EAAE,YAAY,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB,gCA6BA,CAAC"}

package/dist/src/views/auth/settings/devices/revoke-device-button.js

@@ -0,0 +1 @@
+"use client";import{jsx as _jsx}from"react/jsx-runtime";import{LogOutIcon}from"lucide-react";import{toast}from"sonner";import{useTranslations}from"use-intl";import{ConfirmActionAlertDialog}from"../../../../components/confirm-action/confirm-action-alert-dialog.js";import{Button}from"../../../../components/ui/button.js";export const RevokeDeviceButton=({onRevoke,os,publicId})=>{const t=useTranslations("core.auth.settings.devices.revoke");const tGlobal=useTranslations("core.global.errors");return _jsx(ConfirmActionAlertDialog,{description:t("desc",{os}),onSubmit:async({onClose})=>{const result=await onRevoke({publicId});if(result.error){toast.error(tGlobal("title"),{description:tGlobal("internal_server_error")});return}toast.success(t("success"));onClose()},textSubmit:t("confirm"),title:t("title"),children:_jsx(Button,{"aria-label":t("action"),size:"icon-sm",variant:"destructive",children:_jsx(LogOutIcon,{})})})};

package/dist/src/views/auth/settings/nav-content.d.ts

@@ -0,0 +1,6 @@
+import type { AuthLinkComponent } from "../auth-link";
+export declare const SettingsNavContent: ({ LinkComponent, pathname, }: {
+    LinkComponent: AuthLinkComponent;
+    pathname: string;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=nav-content.d.ts.map

package/dist/src/views/auth/settings/nav-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nav-content.d.ts","sourceRoot":"","sources":["../../../../../src/views/auth/settings/nav-content.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AA0BtD,eAAO,MAAM,kBAAkB,GAAI,8BAGhC;IACD,aAAa,EAAE,iBAAiB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB,gCA2BA,CAAC"}

package/dist/src/views/auth/settings/nav-content.js

@@ -0,0 +1 @@
+"use client";import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{ChevronRightIcon,KeyRoundIcon,MonitorSmartphoneIcon,UserRoundIcon}from"lucide-react";import{useTranslations}from"use-intl";import{buttonVariants}from"../../../components/ui/button.js";import{cn}from"../../../lib/utils.js";import{isSettingsNavItemActive,SETTINGS_NAV_ITEMS}from"./settings-nav.js";const ICONS={devices:MonitorSmartphoneIcon,overview:UserRoundIcon,security:KeyRoundIcon};export const SettingsNavContent=({LinkComponent,pathname})=>{const t=useTranslations("core.auth.settings.nav");return _jsx("nav",{className:"flex flex-col gap-1",children:SETTINGS_NAV_ITEMS.map(item=>{const Icon=ICONS[item.key];const isActive=isSettingsNavItemActive(item,pathname);return _jsxs(LinkComponent,{"aria-current":isActive?"page":undefined,className:cn(buttonVariants({variant:isActive?"default":"ghost"}),"w-full justify-start gap-2"),href:item.href,children:[_jsx(Icon,{}),t(item.key),_jsx(ChevronRightIcon,{className:"ml-auto opacity-60 sm:hidden"})]},item.href)})})};

package/dist/src/views/auth/settings/overview/overview.d.ts

@@ -0,0 +1,2 @@
+export declare const OverviewSettings: () => import("react").JSX.Element;
+//# sourceMappingURL=overview.d.ts.map

package/dist/src/views/auth/settings/overview/overview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../../../../../src/views/auth/settings/overview/overview.tsx"],"names":[],"mappings":"AAsBA,eAAO,MAAM,gBAAgB,mCAI5B,CAAC"}

package/dist/src/views/auth/settings/overview/overview.js

@@ -0,0 +1 @@
+"use client";import{jsx as _jsx}from"react/jsx-runtime";import{useTranslations}from"use-intl";import{HeaderContent}from"../../../../components/ui/header-content.js";export const OverviewSettings=()=>{const t=useTranslations("core.auth.settings.nav");return _jsx(HeaderContent,{h2:t("overview")})};

package/dist/src/views/auth/settings/security/security.d.ts

@@ -0,0 +1,2 @@
+export declare const SecuritySettings: () => import("react").JSX.Element;
+//# sourceMappingURL=security.d.ts.map

package/dist/src/views/auth/settings/security/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../../../../src/views/auth/settings/security/security.tsx"],"names":[],"mappings":"AAkBA,eAAO,MAAM,gBAAgB,mCAI5B,CAAC"}

package/dist/src/views/auth/settings/security/security.js

@@ -0,0 +1 @@
+"use client";import{jsx as _jsx}from"react/jsx-runtime";import{useTranslations}from"use-intl";import{HeaderContent}from"../../../../components/ui/header-content.js";export const SecuritySettings=()=>{const t=useTranslations("core.auth.settings.nav");return _jsx(HeaderContent,{h2:t("security")})};

package/dist/src/views/auth/settings/settings-breadcrumb-content.d.ts

@@ -0,0 +1,6 @@
+import type { SettingsNavKey } from "./settings-nav";
+export interface SettingsBreadcrumbContentProps {
+    navKey?: SettingsNavKey;
+}
+export declare const SettingsBreadcrumbContent: ({ navKey, }: SettingsBreadcrumbContentProps) => import("react").JSX.Element;
+//# sourceMappingURL=settings-breadcrumb-content.d.ts.map

package/dist/src/views/auth/settings/settings-breadcrumb-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-breadcrumb-content.d.ts","sourceRoot":"","sources":["../../../../../src/views/auth/settings/settings-breadcrumb-content.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,WAAW,8BAA8B;IAE7C,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAgBD,eAAO,MAAM,yBAAyB,GAAI,aAEvC,8BAA8B,gCAKhC,CAAC"}

package/dist/src/views/auth/settings/settings-breadcrumb-content.js

@@ -0,0 +1 @@
+import{jsx as _jsx,Fragment as _Fragment}from"react/jsx-runtime";import{useTranslations}from"use-intl";export const SettingsBreadcrumbContent=({navKey})=>{const t=useTranslations("core.auth.settings");const tNav=useTranslations("core.auth.settings.nav");return _jsx(_Fragment,{children:navKey===undefined?t("title"):tNav(navKey)})};