@goplusvn/core 0.1.0 → 0.1.1

package/src/ui/primitives/slider.tsx

@@ -0,0 +1,27 @@
+"use client";
+
+import * as SliderPrimitive from "@radix-ui/react-slider";
+
+import type { ComponentProps } from "react";
+
+import { cn } from "../../utils";
+
+export function Slider({
+  className,
+  ...props
+}: ComponentProps<typeof SliderPrimitive.Root>) {
+  return (
+    <SliderPrimitive.Root
+      className={cn(
+        "relative flex w-full touch-none select-none items-center",
+        className,
+      )}
+      {...props}
+    >
+      <SliderPrimitive.Track className="relative h-1.5 w-full grow overflow-hidden rounded-full bg-primary/20">
+        <SliderPrimitive.Range className="absolute h-full bg-primary" />
+      </SliderPrimitive.Track>
+      <SliderPrimitive.Thumb className="cursor-pointer block h-4 w-4 rounded-full border border-primary/50 bg-background shadow-sm transition-colors focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50" />
+    </SliderPrimitive.Root>
+  );
+}

package/src/ui/primitives/status-badge.tsx

@@ -0,0 +1,47 @@
+import { Badge } from "./badge";
+import { STATUS_COLORS, STATUS_ACTIVE, STATUS_INACTIVE } from "../../utils";
+import { cn } from "../../utils";
+
+interface StatusBadgeProps {
+  status: string | unknown;
+  className?: string;
+  label?: string;
+}
+
+export function StatusBadge({
+  status,
+  className,
+  label: customLabel,
+}: StatusBadgeProps) {
+  const statusStr = String(status);
+  const variant = STATUS_COLORS[statusStr] || "secondary";
+
+  // Custom styles for success (green) and warning (yellow) since they might not be in default badge variants
+  let badgeClass = "";
+  if (variant === "success") {
+    badgeClass =
+      "bg-green-500 hover:bg-green-600 text-white border-transparent";
+  } else if (variant === "warning") {
+    badgeClass =
+      "bg-yellow-500 hover:bg-yellow-600 text-white border-transparent";
+  }
+
+  // Use custom label if provided, otherwise fallback to basic mapping or raw value
+  let label = customLabel || statusStr;
+
+  // Fallback mapping if no custom label provided
+  if (!customLabel) {
+    if (statusStr === STATUS_ACTIVE) label = "Active";
+  }
+
+  return (
+    <Badge
+      variant={
+        variant === "success" || variant === "warning" ? "default" : variant
+      }
+      className={cn(badgeClass, className)}
+    >
+      {label}
+    </Badge>
+  );
+}

package/src/ui/primitives/sticky-layout.tsx

@@ -0,0 +1,50 @@
+import { Slot } from "@radix-ui/react-slot";
+
+import type { ComponentProps } from "react";
+
+import { cn } from "../../utils";
+
+interface CardProps extends ComponentProps<"div"> {
+  asChild?: boolean;
+}
+
+export function StickyLayout({ className, asChild, ...props }: CardProps) {
+  const Comp = asChild ? Slot : "div";
+
+  return (
+    <Comp
+      data-slot="sticky-layout"
+      className={cn("grid items-start gap-4 lg:grid-cols-2", className)}
+      {...props}
+    />
+  );
+}
+
+export function StickyLayoutPane({
+  className,
+  ...props
+}: ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="sticky-layout-pane"
+      className={cn(
+        "top-20 flex flex-col items-center text-center space-y-1.5 lg:sticky lg:block lg:text-start",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export function StickyLayoutContent({
+  className,
+  ...props
+}: ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="sticky-layout-content"
+      className={cn("space-y-4", className)}
+      {...props}
+    />
+  );
+}

package/src/ui/primitives/switch.tsx

@@ -0,0 +1,29 @@
+"use client";
+
+import * as React from "react";
+import type { ComponentProps } from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+import { cn } from "../../utils";
+
+export interface SwitchProps
+  extends ComponentProps<typeof SwitchPrimitives.Root> {}
+
+export function Switch({ className, ...props }: SwitchProps) {
+  return (
+    <SwitchPrimitives.Root
+      data-slot="switch"
+      className={cn(
+        "peer inline-flex h-5 w-9 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input",
+        className,
+      )}
+      {...props}
+    >
+      <SwitchPrimitives.Thumb
+        data-slot="switch-thumb"
+        className={cn(
+          "pointer-events-none block h-4 w-4 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0 rtl:data-[state=checked]:-translate-x-4",
+        )}
+      />
+    </SwitchPrimitives.Root>
+  );
+}

package/src/ui/primitives/table.tsx

@@ -0,0 +1,116 @@
+import * as React from "react";
+import { cn } from "../../utils";
+
+const Table = React.forwardRef<
+  HTMLTableElement,
+  React.HTMLAttributes<HTMLTableElement>
+>(({ className, ...props }, ref) => (
+  <div className="relative w-full overflow-auto">
+    <table
+      ref={ref}
+      className={cn("w-max min-w-full caption-bottom text-xs", className)}
+      {...props}
+    />
+  </div>
+));
+Table.displayName = "Table";
+
+const TableHeader = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <thead ref={ref} className={cn("[&_tr]:border-b", className)} {...props} />
+));
+TableHeader.displayName = "TableHeader";
+
+const TableBody = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tbody
+    ref={ref}
+    className={cn("[&_tr:last-child]:border-0", className)}
+    {...props}
+  />
+));
+TableBody.displayName = "TableBody";
+
+const TableFooter = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tfoot
+    ref={ref}
+    className={cn(
+      "border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
+      className,
+    )}
+    {...props}
+  />
+));
+TableFooter.displayName = "TableFooter";
+
+const TableRow = React.forwardRef<
+  HTMLTableRowElement,
+  React.HTMLAttributes<HTMLTableRowElement>
+>(({ className, ...props }, ref) => (
+  <tr
+    ref={ref}
+    className={cn(
+      "border-b transition-colors even:bg-muted/30 data-[state=selected]:bg-muted",
+      className,
+    )}
+    {...props}
+  />
+));
+TableRow.displayName = "TableRow";
+
+const TableHead = React.forwardRef<
+  HTMLTableCellElement,
+  React.ThHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <th
+    ref={ref}
+    className={cn(
+      "h-9 px-3 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0",
+      className,
+    )}
+    {...props}
+  />
+));
+TableHead.displayName = "TableHead";
+
+const TableCell = React.forwardRef<
+  HTMLTableCellElement,
+  React.TdHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <td
+    ref={ref}
+    className={cn("px-3 py-1.5 align-middle [&:has([role=checkbox])]:pr-0 text-xs", className)}
+    {...props}
+  />
+));
+TableCell.displayName = "TableCell";
+
+const TableCaption = React.forwardRef<
+  HTMLTableCaptionElement,
+  React.HTMLAttributes<HTMLTableCaptionElement>
+>(({ className, ...props }, ref) => (
+  <caption
+    ref={ref}
+    className={cn("mt-4 text-sm text-muted-foreground", className)}
+    {...props}
+  />
+));
+TableCaption.displayName = "TableCaption";
+
+export {
+  Table,
+  TableHeader,
+  TableBody,
+  TableFooter,
+  TableHead,
+  TableRow,
+  TableCell,
+  TableCaption,
+};

package/src/ui/primitives/tabs.tsx

@@ -0,0 +1,55 @@
+"use client";
+
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+
+import { cn } from "../../utils";
+
+const Tabs = TabsPrimitive.Root;
+
+const TabsList = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.List>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.List
+    ref={ref}
+    className={cn(
+      "inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground",
+      className,
+    )}
+    {...props}
+  />
+));
+TabsList.displayName = TabsPrimitive.List.displayName;
+
+const TabsTrigger = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Trigger
+    ref={ref}
+    className={cn(
+      "inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm",
+      className,
+    )}
+    {...props}
+  />
+));
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
+
+const TabsContent = React.forwardRef<
+  React.ElementRef<typeof TabsPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>
+>(({ className, ...props }, ref) => (
+  <TabsPrimitive.Content
+    ref={ref}
+    className={cn(
+      "mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+      className,
+    )}
+    {...props}
+  />
+));
+TabsContent.displayName = TabsPrimitive.Content.displayName;
+
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/src/ui/primitives/toggle-group.tsx

@@ -0,0 +1,70 @@
+"use client";
+
+import { createContext, useContext } from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+
+import type { VariantProps } from "class-variance-authority";
+import type { ComponentProps, ComponentPropsWithoutRef } from "react";
+
+import { cn } from "../../utils";
+
+import { toggleVariants } from "./toggle";
+
+const ToggleGroupContext = createContext<VariantProps<typeof toggleVariants>>({
+  size: "default",
+  variant: "default",
+});
+
+type ToggleGroupProps = ComponentProps<typeof ToggleGroupPrimitive.Root> &
+  VariantProps<typeof toggleVariants>;
+
+export function ToggleGroup({
+  className,
+  variant,
+  size,
+  children,
+  ...props
+}: ToggleGroupProps) {
+  return (
+    <ToggleGroupPrimitive.Root
+      data-slot="toggle-group"
+      className={cn("flex items-center justify-center gap-1", className)}
+      {...props}
+    >
+      <ToggleGroupContext.Provider value={{ variant, size }}>
+        {children}
+      </ToggleGroupContext.Provider>
+    </ToggleGroupPrimitive.Root>
+  );
+}
+
+type ToggleGroupItemProps = ComponentPropsWithoutRef<
+  typeof ToggleGroupPrimitive.Item
+> &
+  VariantProps<typeof toggleVariants>;
+
+export function ToggleGroupItem({
+  className,
+  children,
+  variant,
+  size,
+  ...props
+}: ToggleGroupItemProps) {
+  const context = useContext(ToggleGroupContext);
+
+  return (
+    <ToggleGroupPrimitive.Item
+      data-slot="toggle-group-item"
+      className={cn(
+        toggleVariants({
+          variant: context.variant || variant,
+          size: context.size || size,
+        }),
+        className,
+      )}
+      {...props}
+    >
+      {children}
+    </ToggleGroupPrimitive.Item>
+  );
+}

package/src/ui/primitives/toggle.tsx

@@ -0,0 +1,47 @@
+"use client";
+
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { cva } from "class-variance-authority";
+
+import type { VariantProps } from "class-variance-authority";
+import type { ComponentProps } from "react";
+
+import { cn } from "../../utils";
+
+export const toggleVariants = cva(
+  "cursor-pointer inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground",
+  {
+    variants: {
+      variant: {
+        default: "bg-transparent",
+        outline:
+          "border border-input bg-transparent hover:bg-accent hover:text-accent-foreground",
+      },
+      size: {
+        default: "h-9 px-3",
+        sm: "h-8 px-2",
+        lg: "h-10 px-3",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  },
+);
+
+export function Toggle({
+  className,
+  variant,
+  size,
+  ...props
+}: ComponentProps<typeof TogglePrimitive.Root> &
+  VariantProps<typeof toggleVariants>) {
+  return (
+    <TogglePrimitive.Root
+      data-slot="toggle"
+      className={cn(toggleVariants({ variant, size, className }))}
+      {...props}
+    />
+  );
+}

package/src/ui/primitives/tooltip.tsx

@@ -0,0 +1,59 @@
+"use client";
+
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import type { ComponentProps } from "react";
+import { cn } from "../../utils";
+
+export function TooltipProvider({
+  delayDuration = 0,
+  ...props
+}: ComponentProps<typeof TooltipPrimitive.Provider>) {
+  return (
+    <TooltipPrimitive.Provider
+      data-slot="tooltip-provider"
+      delayDuration={delayDuration}
+      {...props}
+    />
+  );
+}
+
+export function Tooltip({
+  ...props
+}: ComponentProps<typeof TooltipPrimitive.Root>) {
+  return (
+    <TooltipProvider>
+      <TooltipPrimitive.Root data-slot="tooltip" {...props} />
+    </TooltipProvider>
+  );
+}
+
+export function TooltipTrigger({
+  className,
+  ...props
+}: ComponentProps<typeof TooltipPrimitive.Trigger>) {
+  return (
+    <TooltipPrimitive.Trigger
+      data-slot="tooltip-trigger"
+      className={cn("cursor-pointer", className)}
+      {...props}
+    />
+  );
+}
+
+export function TooltipContent({
+  className,
+  sideOffset = 0,
+  ...props
+}: ComponentProps<typeof TooltipPrimitive.Content>) {
+  return (
+    <TooltipPrimitive.Content
+      data-slot="tooltip-content"
+      sideOffset={sideOffset}
+      className={cn(
+        "z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-sm text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        className,
+      )}
+      {...props}
+    />
+  );
+}

package/src/user/components/dangerous-zone.tsx

@@ -0,0 +1,34 @@
+import type { UserType } from "../types";
+import type { DictionaryType } from "../../hooks";
+
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "../../ui";
+import { DeleteAccountForm } from "./delete-account-form";
+
+interface DangerousZoneProps {
+  user: UserType;
+  dictionary?: DictionaryType;
+}
+
+export function DangerousZone({ user, dictionary }: DangerousZoneProps) {
+  const t = dictionary?.profile?.dangerZone;
+  
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>{t?.title || "Dangerous Zone"}</CardTitle>
+        <CardDescription>
+          {t?.description || "Manage sensitive settings, such as account deletion or deactivation. Proceed with caution."}
+        </CardDescription>
+      </CardHeader>
+      <CardContent>
+        <DeleteAccountForm user={user} dictionary={dictionary} />
+      </CardContent>
+    </Card>
+  );
+}

package/src/user/components/delete-account-form.tsx

@@ -0,0 +1,40 @@
+"use client";
+
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useForm } from "react-hook-form";
+
+import type { DeleteAccountFormType, UserType } from "../types";
+import type { DictionaryType } from "../../hooks";
+
+import { DeleteAccountSchema } from "../schemas";
+
+import { ButtonLoading } from "../../ui";
+
+interface DeleteAccountFormProps {
+  user: UserType;
+  dictionary?: DictionaryType;
+}
+
+export function DeleteAccountForm({ user, dictionary }: DeleteAccountFormProps) {
+  const t = dictionary?.profile?.dangerZone;
+  
+  const form = useForm<DeleteAccountFormType>({
+    resolver: zodResolver(DeleteAccountSchema),
+    defaultValues: {
+      ...user,
+    },
+  });
+
+  const { isSubmitting } = form.formState;
+
+  return (
+    <div className="flex gap-x-2">
+      <ButtonLoading isLoading={isSubmitting} variant="outline">
+        {t?.disableAccount || "Disable Account"}
+      </ButtonLoading>
+      <ButtonLoading isLoading={isSubmitting} variant="destructive">
+        {t?.deleteAccount || "Delete Account"}
+      </ButtonLoading>
+    </div>
+  );
+}

package/src/user/components/index.ts

@@ -0,0 +1,4 @@
+export { UserStats } from "./user-stats";
+export { UserToolbar } from "./user-toolbar";
+export { UsersCardView } from "./users-card-view";
+export { UnifiedProfileDialog } from "./unified-profile-dialog";