feat(clientarea): modernize orders and addresses pages with new map layout

- Create ClientAreaMapPage component for client area pages with glass effect
- Update orders page to use new ClientAreaMapPage with filter dropdown
- Update addresses page to use new ClientAreaMapPage with add button
- Remove Profile and Team tabs from MainNavigation (already in user menu)

app/pages/clientarea/orders/index.vue

@@ -1,109 +1,88 @@
 <template>
-  <CatalogPage
-    :items="displayItems"
-    :map-items="mapPoints"
+  <ClientAreaMapPage
+    :items="listItems"
     :loading="isLoading"
-    with-map
     map-id="orders-map"
     point-color="#6366f1"
-    :selected-id="selectedOrderId"
     :hovered-id="hoveredOrderId"
     :total-count="filteredItems.length"
+    :title="t('cabinetNav.orders')"
+    :search-query="searchQuery"
     @select="onSelectOrder"
     @update:hovered-id="hoveredOrderId = $event"
+    @update:search-query="searchQuery = $event"
   >
-    <template #searchBar="{ displayedCount, totalCount }">
-      <CatalogSearchBar
-        v-model:search-query="searchQuery"
-        :active-filters="activeFilterBadges"
-        :displayed-count="displayedCount"
-        :total-count="totalCount"
-        @remove-filter="onRemoveFilter"
-        @search="onSearch"
-      >
-        <template #filters>
-          <div class="p-2 space-y-3">
-            <div>
-              <div class="text-xs font-semibold mb-1 text-base-content/70">{{ t('ordersList.filters.status') }}</div>
-              <ul class="menu menu-compact">
-                <li v-for="filter in filters" :key="filter.id">
-                  <a
-                    :class="{ 'active': selectedFilter === filter.id }"
-                    @click="selectedFilter = filter.id"
-                  >{{ filter.label }}</a>
-                </li>
-              </ul>
-            </div>
-          </div>
-        </template>
-      </CatalogSearchBar>
+    <template #header>
+      <!-- Filter dropdown -->
+      <div class="dropdown dropdown-end">
+        <label tabindex="0" class="btn btn-sm bg-white/10 border-white/20 text-white hover:bg-white/20">
+          <Icon name="lucide:filter" size="14" />
+          {{ selectedFilterLabel }}
+        </label>
+        <ul tabindex="0" class="dropdown-content menu menu-sm z-50 p-2 shadow bg-base-200 rounded-box w-52 mt-2">
+          <li v-for="filter in filters" :key="filter.id">
+            <a
+              :class="{ 'active': selectedFilter === filter.id }"
+              @click="selectedFilter = filter.id"
+            >{{ filter.label }}</a>
+          </li>
+        </ul>
+      </div>
     </template>
 
     <template #card="{ item }">
-      <Card padding="lg" class="cursor-pointer">
-        <Stack gap="4">
-          <Stack direction="row" justify="between" align="center">
-            <Stack gap="1">
-              <Text size="sm" tone="muted">{{ t('ordersList.card.order_label') }}</Text>
-              <Heading :level="3">#{{ item.name }}</Heading>
-            </Stack>
-            <div class="badge badge-outline">
-              {{ getOrderStartDate(item) }} → {{ getOrderEndDate(item) }}
+      <div class="bg-white/10 rounded-lg p-4 hover:bg-white/20 transition-colors">
+        <div class="flex items-center justify-between mb-2">
+          <div>
+            <div class="text-xs text-white/60">{{ t('ordersList.card.order_label') }}</div>
+            <div class="font-semibold">#{{ item.name }}</div>
+          </div>
+          <div class="badge badge-outline text-xs text-white/80 border-white/30">
+            {{ getOrderStartDate(item) }}
+          </div>
+        </div>
+
+        <div class="border-t border-white/10 my-2" />
+
+        <div class="grid grid-cols-2 gap-2 text-sm">
+          <div>
+            <div class="text-xs text-white/60">{{ t('ordersList.card.route') }}</div>
+            <div class="truncate">{{ item.sourceLocationName }} → {{ item.destinationLocationName }}</div>
+          </div>
+          <div>
+            <div class="text-xs text-white/60">{{ t('ordersList.card.status') }}</div>
+            <div class="badge badge-sm" :class="getStatusBadgeClass(item.status)">
+              {{ getStatusText(item.status) }}
             </div>
-          </Stack>
+          </div>
+        </div>
 
-          <div class="divider my-0"></div>
-
-          <Grid :cols="1" :md="3" :gap="3">
-            <Stack gap="1">
-              <Text size="sm" tone="muted">{{ t('ordersList.card.route') }}</Text>
-              <Text weight="semibold">{{ item.sourceLocationName }} → {{ item.destinationLocationName }}</Text>
-            </Stack>
-
-            <Stack gap="1">
-              <Text size="sm" tone="muted">{{ t('ordersList.card.product') }}</Text>
-              <Text>
-                {{ item.orderLines?.[0]?.productName || t('ordersList.card.product_loading') }}
-                <template v-if="item.orderLines?.length > 1">
-                  <span class="badge badge-ghost ml-2">+{{ item.orderLines.length - 1 }}</span>
-                </template>
-              </Text>
-              <Text tone="muted" size="sm">
-                {{ item.orderLines?.[0]?.quantity || 0 }} {{ item.orderLines?.[0]?.unit || t('ordersList.card.unit_tons') }}
-              </Text>
-            </Stack>
-
-            <Stack gap="1">
-              <Text size="sm" tone="muted">{{ t('ordersList.card.status') }}</Text>
-              <Badge :variant="getStatusVariant(item.status)">
-                {{ getStatusText(item.status) }}
-              </Badge>
-              <Text tone="muted" size="sm">{{ t('ordersList.card.stages_completed', { done: getCompletedStages(item), total: item.stages?.length || 0 }) }}</Text>
-            </Stack>
-          </Grid>
-        </Stack>
-      </Card>
+        <div v-if="item.orderLines?.[0]" class="mt-2 text-sm">
+          <div class="text-xs text-white/60">{{ t('ordersList.card.product') }}</div>
+          <div>
+            {{ item.orderLines[0].productName }}
+            <span v-if="item.orderLines.length > 1" class="badge badge-ghost badge-xs ml-1">
+              +{{ item.orderLines.length - 1 }}
+            </span>
+          </div>
+        </div>
+      </div>
     </template>
 
     <template #empty>
-      <EmptyState
-        icon="📦"
-        :title="t('orders.no_orders')"
-        :description="t('orders.no_orders_desc')"
-        :action-label="t('orders.create_new')"
-        :action-to="localePath('/clientarea')"
-        action-icon="lucide:plus"
-      />
+      <div class="text-center py-8">
+        <div class="text-4xl mb-2">📦</div>
+        <div class="font-semibold mb-1">{{ t('orders.no_orders') }}</div>
+        <div class="text-sm text-white/60">{{ t('orders.no_orders_desc') }}</div>
+      </div>
     </template>
-  </CatalogPage>
+  </ClientAreaMapPage>
 </template>
 
 <script setup lang="ts">
-import type { MapBounds } from '~/components/catalog/CatalogMap.vue'
 import type { GetTeamOrdersQueryResult } from '~/composables/graphql/team/orders-generated'
 
 type TeamOrder = NonNullable<NonNullable<GetTeamOrdersQueryResult['getTeamOrders']>[number]>
-type TeamOrderStage = NonNullable<NonNullable<TeamOrder['stages']>[number]>
 
 definePageMeta({
   layout: 'topnav',
@@ -123,19 +102,18 @@ const {
   getStatusText
 } = useTeamOrders()
 
-const selectedOrderId = ref<string>()
 const hoveredOrderId = ref<string>()
-
-// Search bar
 const searchQuery = ref('')
 
-// Search with map checkbox
-const searchWithMap = ref(false)
-const currentBounds = ref<MapBounds | null>(null)
+// Selected filter label
+const selectedFilterLabel = computed(() => {
+  const filter = filters.value.find(f => f.id === selectedFilter.value)
+  return filter?.label || t('ordersList.filters.status')
+})
 
 // List items - one per order
 const listItems = computed(() => {
-  return filteredItems.value
+  let items = filteredItems.value
     .filter(order => order.uuid)
     .map(order => ({
       ...order,
@@ -145,79 +123,22 @@ const listItems = computed(() => {
       longitude: order.sourceLongitude,
       country: order.sourceLocationName
     }))
-})
 
-// Map points - two per order (source + destination)
-interface MapPoint {
-  uuid: string
-  name: string
-  latitude: number
-  longitude: number
-}
-
-const mapPoints = computed(() => {
-  const result: MapPoint[] = []
-  filteredItems.value.forEach(order => {
-    // Source point
-    if (order.sourceLatitude && order.sourceLongitude) {
-      result.push({
-        uuid: `${order.uuid}-source`,
-        name: `📦 ${order.sourceLocationName}`,
-        latitude: order.sourceLatitude,
-        longitude: order.sourceLongitude
-      })
-    }
-    // Destination point - get from last stage
-    const lastStage = order.stages?.[order.stages.length - 1]
-    if (lastStage?.destinationLatitude && lastStage?.destinationLongitude) {
-      result.push({
-        uuid: `${order.uuid}-dest`,
-        name: `🏁 ${order.destinationLocationName}`,
-        latitude: lastStage.destinationLatitude,
-        longitude: lastStage.destinationLongitude
-      })
-    }
-  })
-  return result
-})
-
-// Filtered items when searchWithMap is enabled
-const displayItems = computed(() => {
-  if (!searchWithMap.value || !currentBounds.value) return listItems.value
-  return listItems.value.filter(item => {
-    if (item.latitude == null || item.longitude == null) return false
-    const { west, east, north, south } = currentBounds.value!
-    const lng = Number(item.longitude)
-    const lat = Number(item.latitude)
-    return lng >= west && lng <= east && lat >= south && lat <= north
-  })
-})
-
-// Active filter badges
-const activeFilterBadges = computed(() => {
-  const badges: { id: string; label: string }[] = []
-  if (selectedFilter.value && selectedFilter.value !== 'all') {
-    const filter = filters.value.find(f => f.id === selectedFilter.value)
-    if (filter) badges.push({ id: `status:${filter.id}`, label: filter.label })
+  // Apply search filter
+  if (searchQuery.value) {
+    const query = searchQuery.value.toLowerCase()
+    items = items.filter(item =>
+      item.name?.toLowerCase().includes(query) ||
+      item.sourceLocationName?.toLowerCase().includes(query) ||
+      item.destinationLocationName?.toLowerCase().includes(query)
+    )
   }
-  return badges
+
+  return items
 })
 
-// Remove filter badge
-const onRemoveFilter = (id: string) => {
-  if (id.startsWith('status:')) {
-    selectedFilter.value = 'all'
-  }
-}
-
-// Search handler
-const onSearch = () => {
-  // TODO: Implement search
-}
-
 const onSelectOrder = (item: { uuid?: string | null }) => {
   if (item.uuid) {
-    selectedOrderId.value = item.uuid
     navigateTo(localePath(`/clientarea/orders/${item.uuid}`))
   }
 }
@@ -229,34 +150,14 @@ const getOrderStartDate = (order: TeamOrder) => {
   return formatDate(order.createdAt)
 }
 
-const getOrderEndDate = (order: TeamOrder) => {
-  let latestDate: Date | null = null
-  order.stages?.forEach((stage) => {
-    if (!stage) return
-    stage.trips?.forEach((trip) => {
-      if (!trip) return
-      const endDate = trip.actualUnloadingDate || trip.plannedUnloadingDate
-      if (endDate) {
-        const date = new Date(endDate)
-        if (!latestDate || date > latestDate) {
-          latestDate = date
-        }
-      }
-    })
-  })
-  if (latestDate) return formatDate((latestDate as Date).toISOString())
-  if (order.createdAt) {
-    const fallbackDate = new Date(order.createdAt)
-    fallbackDate.setMonth(fallbackDate.getMonth() + 1)
-    return formatDate(fallbackDate.toISOString())
+const getStatusBadgeClass = (status?: string) => {
+  const variant = getStatusVariant(status)
+  switch (variant) {
+    case 'success': return 'badge-success'
+    case 'warning': return 'badge-warning'
+    case 'error': return 'badge-error'
+    default: return 'badge-ghost'
   }
-  return t('ordersDetail.labels.dates_undefined')
-}
-
-const getCompletedStages = (order: TeamOrder) => {
-  if (!order.stages?.length) return 0
-  // Note: StageType doesn't have a status field, count all stages for now
-  return order.stages.filter((stage): stage is TeamOrderStage => stage !== null).length
 }
 
 const formatDate = (date: string) => {
@@ -266,8 +167,7 @@ const formatDate = (date: string) => {
     if (isNaN(dateObj.getTime())) return t('ordersDetail.labels.dates_undefined')
     return new Intl.DateTimeFormat('ru-RU', {
       day: 'numeric',
-      month: 'long',
-      year: 'numeric'
+      month: 'short'
     }).format(dateObj)
   } catch {
     return t('ordersDetail.labels.dates_undefined')