xertica-ui 1.0.0

package/components/ui/route-map.tsx

@@ -0,0 +1,246 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { cn } from './utils';
+import { useGoogleMapsLoader } from './google-maps-loader';
+
+export interface RouteMapProps extends React.HTMLAttributes<HTMLDivElement> {
+  origin: { lat: number; lng: number };
+  destination: { lat: number; lng: number };
+  waypoints?: Array<{ lat: number; lng: number }>;
+  travelMode?: 'DRIVING' | 'WALKING' | 'BICYCLING' | 'TRANSIT';
+  height?: string;
+  apiKey?: string;
+  mapContainerClassName?: string;
+  disableDefaultUI?: boolean;
+  zoomControl?: boolean;
+  streetViewControl?: boolean;
+  mapTypeControl?: boolean;
+  fullscreenControl?: boolean;
+  onRouteCalculated?: (distance: string, duration: string) => void;
+}
+
+const RouteMapContent = React.forwardRef<HTMLDivElement, RouteMapProps & { apiKey: string }>(
+  ({ apiKey, ...props }, ref) => {
+    const { isLoaded, loadError } = useGoogleMapsLoader();
+
+    const {
+      origin,
+      destination,
+      waypoints = [],
+      travelMode = 'DRIVING',
+      height = "450px",
+      mapContainerClassName,
+      disableDefaultUI = false,
+      zoomControl = true,
+      streetViewControl = false,
+      mapTypeControl = false,
+      fullscreenControl = true,
+      onRouteCalculated,
+      className,
+      ...divProps
+    } = props;
+
+    const mapRef = useRef<google.maps.Map | null>(null);
+    const mapContainerRef = useRef<HTMLDivElement>(null);
+    const directionsRendererRef = useRef<google.maps.DirectionsRenderer | null>(null);
+    const isInitializedRef = useRef(false);
+    const isCalculatingRef = useRef(false);
+
+    // Initialize map once
+    useEffect(() => {
+      if (!isLoaded || !mapContainerRef.current || isInitializedRef.current) return;
+
+      isInitializedRef.current = true;
+      const map = new google.maps.Map(mapContainerRef.current, {
+        center: origin,
+        zoom: 13,
+        mapId: 'xertica-route-map',
+        disableDefaultUI,
+        zoomControl,
+        streetViewControl,
+        mapTypeControl,
+        fullscreenControl,
+      });
+
+      mapRef.current = map;
+
+      // Create directions renderer
+      const computedStyle = getComputedStyle(document.documentElement);
+      const primaryColor = computedStyle.getPropertyValue('--primary').trim() || '#4F46E5';
+
+      directionsRendererRef.current = new google.maps.DirectionsRenderer({
+        map: map,
+        suppressMarkers: false,
+        polylineOptions: {
+          strokeColor: primaryColor,
+          strokeWeight: 5,
+          strokeOpacity: 0.8,
+        },
+      });
+
+      return () => {
+        if (directionsRendererRef.current) {
+          directionsRendererRef.current.setMap(null);
+          directionsRendererRef.current = null;
+        }
+        isInitializedRef.current = false;
+        mapRef.current = null;
+      };
+    }, [isLoaded]);
+
+    // Calculate route
+    useEffect(() => {
+      const map = mapRef.current;
+      const renderer = directionsRendererRef.current;
+      
+      if (!map || !renderer || !isLoaded || isCalculatingRef.current) return;
+      if (!origin || !destination) return;
+
+      isCalculatingRef.current = true;
+
+      const directionsService = new google.maps.DirectionsService();
+
+      const request: google.maps.DirectionsRequest = {
+        origin: origin,
+        destination: destination,
+        waypoints: waypoints.map(wp => ({
+          location: wp,
+          stopover: true
+        })),
+        travelMode: google.maps.TravelMode[travelMode],
+      };
+
+      directionsService.route(request, (result, status) => {
+        isCalculatingRef.current = false;
+        
+        if (status === 'OK' && result) {
+          renderer.setDirections(result);
+          
+          // Calculate total distance and duration
+          const route = result.routes[0];
+          if (route?.legs?.length > 0 && onRouteCalculated) {
+            let totalDistance = 0;
+            let totalDuration = 0;
+            
+            route.legs.forEach(leg => {
+              if (leg.distance) totalDistance += leg.distance.value;
+              if (leg.duration) totalDuration += leg.duration.value;
+            });
+            
+            const distanceKm = (totalDistance / 1000).toFixed(1);
+            const distanceText = `${distanceKm} km`;
+            
+            const hours = Math.floor(totalDuration / 3600);
+            const minutes = Math.floor((totalDuration % 3600) / 60);
+            const durationText = hours > 0 ? `${hours}h ${minutes}min` : `${minutes} min`;
+            
+            onRouteCalculated(distanceText, durationText);
+          }
+        }
+      });
+    }, [isLoaded, origin.lat, origin.lng, destination.lat, destination.lng, travelMode]);
+
+    if (loadError) {
+      return (
+        <div
+          ref={ref}
+          className={cn(
+            "relative rounded-[var(--radius-card)] border border-destructive/50 overflow-hidden bg-destructive/5",
+            className
+          )}
+          style={{ height }}
+          {...divProps}
+        >
+          <div className="absolute inset-0 flex items-center justify-center">
+            <div className="text-center space-y-2 p-6">
+              <div className="text-destructive">
+                <svg className="w-12 h-12 mx-auto" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+                </svg>
+              </div>
+              <p className="text-sm text-destructive">Failed to load Google Maps</p>
+              <p className="text-xs text-muted-foreground">Check API key in Settings</p>
+            </div>
+          </div>
+        </div>
+      );
+    }
+
+    if (!isLoaded) {
+      return (
+        <div
+          ref={ref}
+          className={cn(
+            "relative rounded-[var(--radius-card)] border border-border overflow-hidden bg-muted animate-pulse",
+            className
+          )}
+          style={{ height }}
+          {...divProps}
+        />
+      );
+    }
+
+    return (
+      <div
+        ref={ref}
+        className={cn(
+          "relative rounded-[var(--radius-card)] border border-border overflow-hidden",
+          className
+        )}
+        {...divProps}
+      >
+        <div
+          ref={mapContainerRef}
+          style={{ height }}
+          className={cn("rounded-[var(--radius-card)] w-full", mapContainerClassName)}
+        />
+      </div>
+    );
+  }
+);
+RouteMapContent.displayName = "RouteMapContent";
+
+export const RouteMap = React.forwardRef<HTMLDivElement, RouteMapProps>(
+  (props, ref) => {
+    const effectiveApiKey = props.apiKey || "";
+
+    const isValidKey = effectiveApiKey && 
+                       effectiveApiKey !== "YOUR_GOOGLE_MAPS_API_KEY_HERE" && 
+                       effectiveApiKey.startsWith("AIza");
+
+    if (!isValidKey) {
+      const { 
+        origin, destination, waypoints, travelMode, height, apiKey,
+        mapContainerClassName, disableDefaultUI, zoomControl,
+        streetViewControl, mapTypeControl, fullscreenControl,
+        onRouteCalculated, ...divProps 
+      } = props;
+
+      return (
+        <div
+          ref={ref}
+          className={cn(
+            "relative rounded-[var(--radius-card)] border border-border overflow-hidden bg-muted",
+            props.className
+          )}
+          style={{ height: props.height || "450px" }}
+          {...divProps}
+        >
+          <div className="absolute inset-0 flex items-center justify-center bg-gradient-to-br from-muted/50 to-muted">
+            <div className="text-center space-y-3 p-6">
+              <div className="w-16 h-16 mx-auto bg-primary/10 rounded-full flex items-center justify-center">
+                <svg className="w-8 h-8 text-primary" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17.657 16.657L13.414 20.9a1.998 1.998 0 01-2.827 0l-4.244-4.243a8 8 0 1111.314 0z" />
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 11a3 3 0 11-6 0 3 3 0 016 0z" />
+                </svg>
+              </div>
+              <p className="text-sm text-muted-foreground">Configure Google Maps API Key in Settings</p>
+            </div>
+          </div>
+        </div>
+      );
+    }
+
+    return <RouteMapContent ref={ref} {...props} apiKey={effectiveApiKey} />;
+  }
+);
+RouteMap.displayName = "RouteMap";

package/components/ui/scroll-area.tsx

@@ -0,0 +1,58 @@
+"use client";
+
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+
+import { cn } from "./utils";
+
+function ScrollArea({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.Root>) {
+  return (
+    <ScrollAreaPrimitive.Root
+      data-slot="scroll-area"
+      className={cn("relative", className)}
+      {...props}
+    >
+      <ScrollAreaPrimitive.Viewport
+        data-slot="scroll-area-viewport"
+        className="focus-visible:ring-ring/50 size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:outline-1"
+      >
+        {children}
+      </ScrollAreaPrimitive.Viewport>
+      <ScrollBar />
+      <ScrollAreaPrimitive.Corner />
+    </ScrollAreaPrimitive.Root>
+  );
+}
+
+function ScrollBar({
+  className,
+  orientation = "vertical",
+  ...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>) {
+  return (
+    <ScrollAreaPrimitive.ScrollAreaScrollbar
+      data-slot="scroll-area-scrollbar"
+      orientation={orientation}
+      className={cn(
+        "flex touch-none p-px transition-colors select-none",
+        orientation === "vertical" &&
+          "h-full w-2.5 border-l border-l-transparent",
+        orientation === "horizontal" &&
+          "h-2.5 flex-col border-t border-t-transparent",
+        className,
+      )}
+      {...props}
+    >
+      <ScrollAreaPrimitive.ScrollAreaThumb
+        data-slot="scroll-area-thumb"
+        className="bg-border relative flex-1 rounded-full"
+      />
+    </ScrollAreaPrimitive.ScrollAreaScrollbar>
+  );
+}
+
+export { ScrollArea, ScrollBar };

package/components/ui/search.tsx

@@ -0,0 +1,70 @@
+import * as React from "react";
+import { Search as SearchIcon, X } from "lucide-react";
+import { cn } from "./utils";
+
+export interface SearchProps extends React.InputHTMLAttributes<HTMLInputElement> {
+  onSearch?: (value: string) => void;
+  onClear?: () => void;
+  containerClassName?: string;
+}
+
+const Search = React.forwardRef<HTMLInputElement, SearchProps>(
+  ({ className, containerClassName, onSearch, onClear, onChange, ...props }, ref) => {
+    const [value, setValue] = React.useState(props.value || "");
+
+    React.useEffect(() => {
+      if (props.value !== undefined) {
+        setValue(props.value);
+      }
+    }, [props.value]);
+
+    const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+      const newValue = e.target.value;
+      setValue(newValue);
+      onChange?.(e);
+      onSearch?.(newValue);
+    };
+
+    const handleClear = () => {
+      setValue("");
+      onClear?.();
+      onSearch?.("");
+    };
+
+    const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+      if (e.key === "Escape") {
+        handleClear();
+      }
+    };
+
+    return (
+      <div className={cn("relative w-full", containerClassName)}>
+        <SearchIcon className="absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+        <input
+          ref={ref}
+          type="search"
+          value={value}
+          onChange={handleChange}
+          onKeyDown={handleKeyDown}
+          className={cn(
+            "flex h-10 w-full rounded-[var(--radius)] border border-input bg-input-background px-10 py-2 text-foreground ring-offset-background transition-colors file:border-0 file:bg-transparent placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+            className
+          )}
+          {...props}
+        />
+        {value && (
+          <button
+            type="button"
+            onClick={handleClear}
+            className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground transition-colors hover:text-foreground focus:outline-none"
+          >
+            <X className="h-4 w-4" />
+          </button>
+        )}
+      </div>
+    );
+  }
+);
+Search.displayName = "Search";
+
+export { Search };

package/components/ui/select.tsx

@@ -0,0 +1,176 @@
+"use client"
+
+import * as React from "react"
+import * as SelectPrimitive from "@radix-ui/react-select"
+import { Check, ChevronDown, ChevronUp } from "lucide-react"
+
+import { cn } from "./utils"
+
+const Select = SelectPrimitive.Root
+
+const SelectGroup = SelectPrimitive.Group
+
+const SelectValue = SelectPrimitive.Value
+
+const SelectTrigger = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Trigger>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+  }
+>(({ className, children, size = "default", ...props }, ref) => (
+  <SelectPrimitive.Trigger
+    ref={ref}
+    data-slot="select-trigger"
+    data-size={size}
+    className={cn(
+      "flex w-full items-center justify-between gap-2 px-3 py-2 text-sm bg-background rounded-[var(--radius)] border border-border transition-colors outline-none whitespace-nowrap text-foreground",
+      "data-[placeholder]:text-muted-foreground",
+      "focus:ring-2 focus:ring-primary focus:border-transparent",
+      "disabled:cursor-not-allowed disabled:opacity-50",
+      "data-[size=default]:h-9 data-[size=sm]:h-8",
+      "[&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+      "*:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2",
+      className
+    )}
+    {...props}
+  >
+    {children}
+    <SelectPrimitive.Icon asChild>
+      <ChevronDown className="size-4 opacity-50" />
+    </SelectPrimitive.Icon>
+  </SelectPrimitive.Trigger>
+))
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName
+
+const SelectScrollUpButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollUpButton
+    ref={ref}
+    data-slot="select-scroll-up-button"
+    className={cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    )}
+    {...props}
+  >
+    <ChevronUp className="size-4" />
+  </SelectPrimitive.ScrollUpButton>
+))
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName
+
+const SelectScrollDownButton = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.ScrollDownButton
+    ref={ref}
+    data-slot="select-scroll-down-button"
+    className={cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    )}
+    {...props}
+  >
+    <ChevronDown className="size-4" />
+  </SelectPrimitive.ScrollDownButton>
+))
+SelectScrollDownButton.displayName =
+  SelectPrimitive.ScrollDownButton.displayName
+
+const SelectContent = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>
+>(({ className, children, position = "popper", ...props }, ref) => (
+  <SelectPrimitive.Portal>
+    <SelectPrimitive.Content
+      ref={ref}
+      data-slot="select-content"
+      className={cn(
+        "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-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 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-[var(--radius)] border border-border shadow-md",
+        position === "popper" &&
+          "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+        className
+      )}
+      position={position}
+      {...props}
+    >
+      <SelectScrollUpButton />
+      <SelectPrimitive.Viewport
+        className={cn(
+          "p-1",
+          position === "popper" &&
+            "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1"
+        )}
+      >
+        {children}
+      </SelectPrimitive.Viewport>
+      <SelectScrollDownButton />
+    </SelectPrimitive.Content>
+  </SelectPrimitive.Portal>
+))
+SelectContent.displayName = SelectPrimitive.Content.displayName
+
+const SelectLabel = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Label>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Label>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.Label
+    ref={ref}
+    data-slot="select-label"
+    className={cn("text-muted-foreground px-2 py-1.5 text-xs", className)}
+    {...props}
+  />
+))
+SelectLabel.displayName = SelectPrimitive.Label.displayName
+
+const SelectItem = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
+>(({ className, children, ...props }, ref) => (
+  <SelectPrimitive.Item
+    ref={ref}
+    data-slot="select-item"
+    className={cn(
+      "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+      className
+    )}
+    {...props}
+  >
+    <span className="absolute right-2 flex size-3.5 items-center justify-center">
+      <SelectPrimitive.ItemIndicator>
+        <Check className="size-4" />
+      </SelectPrimitive.ItemIndicator>
+    </span>
+
+    <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+  </SelectPrimitive.Item>
+))
+SelectItem.displayName = SelectPrimitive.Item.displayName
+
+const SelectSeparator = React.forwardRef<
+  React.ElementRef<typeof SelectPrimitive.Separator>,
+  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>
+>(({ className, ...props }, ref) => (
+  <SelectPrimitive.Separator
+    ref={ref}
+    data-slot="select-separator"
+    className={cn("bg-border pointer-events-none -mx-1 my-1 h-px", className)}
+    {...props}
+  />
+))
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName
+
+export {
+  Select,
+  SelectGroup,
+  SelectValue,
+  SelectTrigger,
+  SelectContent,
+  SelectLabel,
+  SelectItem,
+  SelectSeparator,
+  SelectScrollUpButton,
+  SelectScrollDownButton,
+}

package/components/ui/separator.tsx

@@ -0,0 +1,28 @@
+"use client";
+
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+
+import { cn } from "./utils";
+
+function Separator({
+  className,
+  orientation = "horizontal",
+  decorative = true,
+  ...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+  return (
+    <SeparatorPrimitive.Root
+      data-slot="separator-root"
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export { Separator };