@burdenoff/microfe-movethewheels 2026.704.2 → 2026.713.1

package/dist/movethewheels/components/maps/TrackingMap.d.ts

@@ -0,0 +1,29 @@
+export interface TrackPoint {
+    lat: number;
+    lng: number;
+    timestamp?: string;
+}
+export interface TrackEndpoint {
+    lat: number;
+    lng: number;
+    label?: string;
+}
+interface TrackingMapProps {
+    origin?: TrackEndpoint | null;
+    destination?: TrackEndpoint | null;
+    /** Ordered breadcrumb of positions the shipment has passed through. */
+    trail: TrackPoint[];
+    current?: TrackEndpoint | null;
+    height?: number | string;
+    className?: string;
+    /** Trail polyline color (design-token string). Defaults to brand blue. */
+    trailColor?: string;
+    emptyMessage?: string;
+}
+/**
+ * TrackingMap — renders a shipment's breadcrumb trail with origin/destination
+ * pins and a live "current position" dot. Everything is filtered for real
+ * coordinates so a missing GPS fix never plots at null-island.
+ */
+export declare function TrackingMap({ origin, destination, trail, current, height, className, trailColor, emptyMessage, }: TrackingMapProps): import("react").JSX.Element;
+export {};

package/dist/movethewheels/components/maps/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Map primitives (react-leaflet + OpenStreetMap tiles) — brand-styled markers,
+ * mount-safe, responsive, honest empty states. Coordinates at null-island (0,0)
+ * or non-finite values are always filtered out.
+ */
+export { LogisticsMap, type LogisticsMarker, type LogisticsRoute } from './LogisticsMap';
+export { RouteMap, type RouteStop } from './RouteMap';
+export { TrackingMap, type TrackPoint, type TrackEndpoint } from './TrackingMap';
+export { MapCanvas } from './MapCanvas';
+export { createPinIcon, createStopIcon, createCurrentIcon, isRealCoord, type MapMarkerStatus, } from './leaflet-setup';

package/dist/movethewheels/components/maps/leaflet-setup.d.ts

@@ -0,0 +1,31 @@
+import { default as L } from 'leaflet';
+
+/**
+ * OpenStreetMap raster tiles. There is no CSP blocking external tiles in the
+ * app-shell, so we use the standard OSM tile server.
+ */
+export declare const OSM_TILE_URL = "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png";
+export declare const OSM_ATTRIBUTION = "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors";
+export type MapMarkerStatus = 'active' | 'in_transit' | 'idle' | 'delayed' | 'delivered' | 'origin' | 'destination' | 'default';
+/**
+ * A coordinate is "real" only when it is finite and not the null-island (0,0)
+ * sentinel that backends emit for "unknown location". We never plot those.
+ */
+export declare function isRealCoord(lat: unknown, lng: unknown): lat is number;
+/**
+ * A brand-styled teardrop pin (orange by default) with a white truck glyph.
+ * Built as an HTML `divIcon` because Leaflet's default marker PNGs break under
+ * bundlers.
+ */
+export declare function createPinIcon(status?: MapMarkerStatus, options?: {
+    pulse?: boolean;
+    glyph?: boolean;
+}): L.DivIcon;
+/**
+ * A small numbered circle marker for ordered route stops.
+ */
+export declare function createStopIcon(sequence: number, color?: string): L.DivIcon;
+/**
+ * A pulsing dot for the shipment's current/live position.
+ */
+export declare function createCurrentIcon(color?: string): L.DivIcon;

package/dist/movethewheels/components/ui.d.ts

@@ -0,0 +1,22 @@
+/**
+ * UI Component re-exports from @burdenoff/fe-libs
+ * All styled components are imported from the shared fe-libs package
+ */
+export { Button, Badge, Card, CardContent, CardHeader, CardTitle, CardDescription, CardFooter, Input, Skeleton, Separator, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Tabs, TabsList, TabsTrigger, TabsContent, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, DialogTrigger, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, DropdownMenuSeparator, Label, Textarea, Switch, Checkbox, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, ScrollArea, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from '@burdenoff/fe-libs/ui';
+import * as React from 'react';
+interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+export { Progress };
+interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface AvatarImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+}
+declare const AvatarImage: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
+interface AvatarFallbackProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLDivElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/movethewheels/constants/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Constants barrel export
+ *
+ * Status color maps use fe-libs semantic status tokens (never raw palette
+ * classes) so they adapt automatically across light/dark and product themes.
+ * Definitions live in fe-libs/src/shared/styles/app-shell.css.
+ */
+export interface StatusColor {
+    bg: string;
+    text: string;
+    border?: string;
+}
+export declare const ORDER_STATUS_COLORS: Record<string, StatusColor>;
+export declare const VEHICLE_STATUS_COLORS: Record<string, StatusColor>;
+export declare const DRIVER_STATUS_COLORS: Record<string, StatusColor>;
+export declare const PRIORITY_COLORS: Record<string, StatusColor>;
+export declare const ROUTE_STATUS_COLORS: Record<string, StatusColor>;
+export declare const CUSTOMER_TYPE_LABELS: Record<string, string>;
+export declare const VEHICLE_TYPE_LABELS: Record<string, string>;
+export declare const WAREHOUSE_TYPE_LABELS: Record<string, string>;

package/dist/movethewheels/hooks/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MoveTheWheels Hooks
+ *
+ * All custom hooks for data access and operations.
+ */
+export { useOrders, useOrder, useOrderStats } from './useOrders';
+export { useFleet, useVehicles, useVehicle, useDrivers, useDriver, useFleetStats, } from './useFleet';
+export { useInventory, useProducts, useProduct, useWarehouses, useWarehouse, useInventoryStats, } from './useInventory';
+export { useCustomers, useCustomer, useCustomerStats } from './useCustomers';
+export { useRoutes, useRoute, useRouteStats } from './useRoutes';
+export { useAnalytics, useDashboardMetrics, useRevenueAnalytics, useOrderAnalytics, useFleetAnalytics, usePerformanceAnalytics, useFinanceMetrics, type FinanceMetrics, } from './useAnalytics';
+export { useTracking, useOrderTracking, useVehicleTracking, useDriverTracking, useLiveTracking, useTrackingAlerts, useGeofence, } from './useTracking';
+export { useAssistant } from './useAssistant';
+export { useReports } from './useReports';
+export { useImportExport } from './useImportExport';
+export { useModuleSettings } from './useSettings';
+export { useEntityDocuments, type EntityDocument, type EntityDocumentType, } from './useEntityDocuments';

package/dist/movethewheels/hooks/useAnalytics.d.ts

@@ -0,0 +1,136 @@
+import { Analytics } from '../types';
+
+interface UseAnalyticsOptions {
+    dateRange?: {
+        from: Date;
+        to: Date;
+    };
+}
+interface UseAnalyticsResult {
+    analytics: Analytics;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+export declare function useAnalytics(_options?: UseAnalyticsOptions): UseAnalyticsResult;
+export declare function useDashboardMetrics(): {
+    metrics: {
+        orders: {
+            total: number;
+            pending: number;
+            inTransit: number;
+            delivered: number;
+            today: number;
+        };
+        fleet: {
+            totalVehicles: number;
+            activeVehicles: number;
+            totalDrivers: number;
+            availableDrivers: number;
+        };
+        revenue: {
+            total: number;
+            avgOrderValue: number;
+            currency: string;
+        };
+        performance: {
+            onTimeDeliveryRate: number;
+            avgDriverRating: number;
+        };
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useRevenueAnalytics(period?: 'daily' | 'weekly' | 'monthly'): {
+    revenueData: {
+        label: string;
+        value: number;
+    }[];
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useOrderAnalytics(): {
+    orderData: {
+        byStatus: Array<{
+            status: string;
+            count: number;
+        }>;
+        byType: Array<{
+            type: string;
+            count: number;
+        }>;
+        byPriority: Array<{
+            priority: string;
+            count: number;
+        }>;
+        trends: Array<{
+            date: string;
+            orders: number;
+        }>;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useFleetAnalytics(): {
+    fleetData: {
+        vehicleUtilization: number;
+        avgFuelLevel: number;
+        vehiclesByType: Array<{
+            type: string;
+            count: number;
+        }>;
+        driverPerformance: Array<{
+            id: string;
+            name: string;
+            completedOrders: number;
+            rating: number;
+            onTimeRate: number;
+        }>;
+        fleetStats: {
+            utilization: number;
+            totalVehicles: number;
+            activeVehicles: number;
+            maintenanceVehicles: number;
+            outOfServiceVehicles: number;
+            fuelEfficiency: number;
+        };
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export interface FinanceMetrics {
+    totalRevenue: number;
+    deliveredRevenue: number;
+    averageOrderValue: number;
+    fuelCost: number;
+    openInvoices: number;
+}
+/**
+ * Real finance figures straight from Query.financeMetrics — no simulated splits.
+ * `deliveredRevenue` is money already collected on delivered orders; `openInvoices`
+ * is the count of orders still owing. Both come from the service, never inferred.
+ */
+export declare function useFinanceMetrics(): {
+    metrics: FinanceMetrics;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+export declare function usePerformanceAnalytics(): {
+    performanceData: {
+        driverRatings: Array<{
+            name: string;
+            overall: number;
+            punctuality: number;
+            communication: number;
+            handling: number;
+        }>;
+        onTimePickup: number;
+        onTimeDelivery: number;
+        damagedItems: number;
+        customerComplaints: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/movethewheels/hooks/useAssistant.d.ts

@@ -0,0 +1,17 @@
+export interface AssistantAnswer {
+    answer: string;
+    generatedAt: string;
+    question: string;
+}
+interface UseAssistantResult {
+    ask: (question: string) => Promise<AssistantAnswer>;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * useAssistant — queries the real logistics assistant (Query.assistantInsights).
+ * The backend answers from the caller's own operational data; there is no
+ * client-side canned response.
+ */
+export declare function useAssistant(): UseAssistantResult;
+export {};

package/dist/movethewheels/hooks/useCustomers.d.ts

@@ -0,0 +1,39 @@
+import { Customer, CustomerFilter } from '../types';
+
+interface UseCustomersOptions {
+    filters?: CustomerFilter;
+    limit?: number;
+    offset?: number;
+}
+interface UseCustomersResult {
+    customers: Customer[];
+    totalCustomers: number;
+    /** True when the last fetch returned a full page (rawCount === limit). */
+    hasMore: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    createCustomer: (customer: Partial<Customer>) => Promise<Customer>;
+    updateCustomer: (id: string, updates: Partial<Customer>) => Promise<Customer>;
+    deleteCustomer: (id: string) => Promise<void>;
+}
+export declare function useCustomers(options?: UseCustomersOptions): UseCustomersResult;
+export declare function useCustomer(customerId: string | undefined): {
+    customer: Customer | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+export declare function useCustomerStats(): {
+    stats: {
+        total: number;
+        b2b: number;
+        b2c: number;
+        active: number;
+        inactive: number;
+        avgRating: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/movethewheels/hooks/useEntityDocuments.d.ts

@@ -0,0 +1,31 @@
+/**
+ * useEntityDocuments — real document listing via wspace-files-svc.
+ *
+ * MoveTheWheels does NOT own a Document model. Documents attached to a vehicle,
+ * driver or order live in the platform Files module (wspace-files-svc), which
+ * federates into the same workspace gateway. We tag each uploaded file with two
+ * marqueue entity tags — `mtwEntityType` and `mtwEntityId` — and list them back
+ * here through the federated `files(filter:{ tags:[...] })` query.
+ *
+ * There is no upload UI here (out of scope): uploading/managing happens in the
+ * Files module, deep-linked from DocumentsCard. This hook is read-only.
+ */
+export type EntityDocumentType = 'vehicle' | 'driver' | 'order';
+export interface EntityDocument {
+    id: string;
+    name: string;
+    /** Byte size (File.size is BigInt → string over JSON). */
+    size: number;
+    mimeType: string;
+    createdAt: Date;
+    /** Presigned download/open link, when the files service exposes one. */
+    downloadUrl?: string;
+}
+interface UseEntityDocumentsResult {
+    documents: EntityDocument[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+export declare function useEntityDocuments(entityType: EntityDocumentType, entityId: string | undefined): UseEntityDocumentsResult;
+export {};

package/dist/movethewheels/hooks/useFleet.d.ts

@@ -0,0 +1,100 @@
+import { Driver, DriverStatus, FleetFilter, Vehicle, VehicleStatus } from '../types';
+
+interface UseFleetOptions {
+    filters?: FleetFilter;
+}
+export interface CreateVehicleInput {
+    vehicleNumber: string;
+    /** VehicleType enum value, e.g. `TRUCK`, `VAN`. */
+    type: string;
+    make?: string;
+    model?: string;
+    licensePlate?: string;
+}
+export interface CreateDriverInput {
+    employeeId: string;
+    firstName: string;
+    lastName: string;
+    email?: string;
+    phone?: string;
+    licenseNumber?: string;
+}
+interface UseFleetResult {
+    vehicles: Vehicle[];
+    drivers: Driver[];
+    totalVehicles: number;
+    totalDrivers: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    createVehicle: (input: CreateVehicleInput) => Promise<Vehicle>;
+    createDriver: (input: CreateDriverInput) => Promise<Driver>;
+    updateVehicle: (id: string, input: CreateVehicleInput) => Promise<Vehicle>;
+    updateDriver: (id: string, input: CreateDriverInput) => Promise<Driver>;
+}
+export declare function useFleet(options?: UseFleetOptions): UseFleetResult;
+interface UseListOptions {
+    limit?: number;
+    offset?: number;
+}
+interface UseVehiclesResult {
+    vehicles: Vehicle[];
+    totalVehicles: number;
+    /** True when the last fetch returned a full page (rawCount === limit). */
+    hasMore: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    updateVehicleStatus: (id: string, status: VehicleStatus) => Promise<Vehicle>;
+    assignDriver: (vehicleId: string, driverId: string) => Promise<Vehicle>;
+}
+export declare function useVehicles(options?: UseListOptions): UseVehiclesResult;
+export declare function useVehicle(vehicleId: string | undefined): {
+    vehicle: Vehicle | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+interface UseDriversResult {
+    drivers: Driver[];
+    totalDrivers: number;
+    /** True when the last fetch returned a full page (rawCount === limit). */
+    hasMore: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    updateDriverStatus: (id: string, status: DriverStatus) => Promise<Driver>;
+    assignVehicle: (driverId: string, vehicleId: string) => Promise<Driver>;
+}
+export declare function useDrivers(options?: UseListOptions): UseDriversResult;
+export declare function useDriver(driverId: string | undefined): {
+    driver: Driver | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+export declare function useFleetStats(): {
+    stats: {
+        totalVehicles: number;
+        totalDrivers: number;
+        vehiclesByStatus: {
+            available: number;
+            assigned: number;
+            maintenance: number;
+            out_of_service: number;
+        };
+        driversByStatus: {
+            available: number;
+            busy: number;
+            offline: number;
+            on_break: number;
+        };
+        avgFuelLevel: number;
+        avgDriverRating: number;
+        utilization: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+export {};

package/dist/movethewheels/hooks/useImportExport.d.ts

@@ -0,0 +1,13 @@
+export interface ImportExportResult {
+    success: boolean;
+    message: string;
+    payload?: Record<string, unknown> | null;
+}
+interface UseImportExportResult {
+    exportData: (resource: string, format?: string) => Promise<ImportExportResult>;
+    importData: (resource: string, payload: Record<string, unknown>) => Promise<ImportExportResult>;
+    isBusy: boolean;
+    error: Error | null;
+}
+export declare function useImportExport(): UseImportExportResult;
+export {};

package/dist/movethewheels/hooks/useInventory.d.ts

@@ -0,0 +1,121 @@
+import { Inventory, InventoryFilter, Product, Warehouse } from '../types';
+
+interface UseInventoryOptions {
+    filters?: InventoryFilter;
+}
+export interface CreateProductInput {
+    name: string;
+    sku: string;
+    category?: string;
+    brand?: string;
+    weight?: number;
+}
+export interface CreateWarehouseInput {
+    code: string;
+    name: string;
+    /** WarehouseType enum value, e.g. `DISTRIBUTION`, `FULFILLMENT`. */
+    type: string;
+    address: {
+        street: string;
+        city: string;
+        state: string;
+        postalCode: string;
+        country: string;
+    };
+    totalCapacity?: number;
+}
+interface UseInventoryResult {
+    inventory: Inventory[];
+    products: Product[];
+    warehouses: Warehouse[];
+    totalItems: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    updateStock: (inventoryId: string, quantity: number, reason: string) => Promise<Inventory>;
+    transferStock: (fromWarehouseId: string, toWarehouseId: string, productId: string, quantity: number) => Promise<void>;
+    createProduct: (input: CreateProductInput) => Promise<Product>;
+    createWarehouse: (input: CreateWarehouseInput) => Promise<Warehouse>;
+    updateProduct: (id: string, input: CreateProductInput) => Promise<Product>;
+    updateWarehouse: (id: string, input: CreateWarehouseInput) => Promise<Warehouse>;
+}
+export declare function useInventory(options?: UseInventoryOptions): UseInventoryResult;
+interface UseListOptions {
+    limit?: number;
+    offset?: number;
+}
+export declare function useProducts(options?: UseListOptions): {
+    products: Product[];
+    totalProducts: number;
+    hasMore: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => undefined;
+};
+/**
+ * Bounded aggregate for the Products page "at a glance" tiles. Fetches up to
+ * `sampleSize` products (independent of the paginated list) and computes the
+ * special-handling / temperature-controlled counts so the tiles never reflect
+ * a single truncated page. There is no product *Count field on the frozen
+ * supergraph, so this bounded sample is the aggregate source.
+ */
+export declare function useProductStats(sampleSize?: number): {
+    stats: {
+        total: number;
+        specialHandling: number;
+        temperatureControlled: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useProduct(productId: string | undefined): {
+    product: Product | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => undefined;
+};
+export declare function useWarehouses(options?: UseListOptions): {
+    warehouses: Warehouse[];
+    totalWarehouses: number;
+    hasMore: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => undefined;
+};
+/**
+ * Bounded aggregate for the Warehouses page "at a glance" tiles — fetches up to
+ * `sampleSize` warehouses (independent of the paginated list) so the active /
+ * avg-utilization tiles never reflect a single truncated page.
+ */
+export declare function useWarehouseStats(sampleSize?: number): {
+    stats: {
+        total: number;
+        active: number;
+        avgUtilization: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useWarehouse(warehouseId: string | undefined): {
+    warehouse: Warehouse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => undefined;
+};
+export declare function useInventoryStats(): {
+    stats: {
+        totalItems: number;
+        lowStockItems: number;
+        totalValue: number;
+        totalProducts: number;
+        totalWarehouses: number;
+        warehouseUtilization: Array<{
+            id: string;
+            name: string;
+            utilization: number;
+        }>;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/movethewheels/hooks/useOrders.d.ts

@@ -0,0 +1,53 @@
+import { Order, OrderFilter, OrderStatus } from '../types';
+
+interface UseOrdersOptions {
+    filters?: OrderFilter;
+    limit?: number;
+    offset?: number;
+}
+interface UseOrdersResult {
+    orders: Order[];
+    totalOrders: number;
+    /**
+     * True when the most recent fetch returned a full page (rawCount === limit),
+     * i.e. there may be another page. Used for offset pagers where no grand
+     * total is available.
+     */
+    hasMore: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    createOrder: (order: Partial<Order>) => Promise<Order>;
+    updateOrder: (id: string, updates: Partial<Order>) => Promise<Order>;
+    deleteOrder: (id: string) => Promise<void>;
+    updateOrderStatus: (id: string, status: OrderStatus) => Promise<Order>;
+}
+export declare function useOrders(options?: UseOrdersOptions): UseOrdersResult;
+export declare function useOrder(orderId: string | undefined): {
+    order: Order | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+export declare function useOrderStats(): {
+    stats: {
+        total: number;
+        byStatus: {
+            pending: number;
+            confirmed: number;
+            assigned: number;
+            picked_up: number;
+            in_transit: number;
+            out_for_delivery: number;
+            delivered: number;
+            cancelled: number;
+            failed: number;
+        };
+        totalRevenue: number;
+        todayOrders: number;
+        avgOrderValue: number;
+    };
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};