@open-mercato/core 0.6.7-develop.6669.1.40b669666b → 0.6.7-develop.6671.1.4b925c5096

package/dist/modules/wms/components/backend/WmsInventoryConsolePage.js

@@ -0,0 +1,908 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import Link from "next/link";
+import { useQuery } from "@tanstack/react-query";
+import { Page, PageBody } from "@open-mercato/ui/backend/Page";
+import { DataTable } from "@open-mercato/ui/backend/DataTable";
+import { EmptyState } from "@open-mercato/ui/backend/EmptyState";
+import { RowActions } from "@open-mercato/ui/backend/RowActions";
+import { ComboboxInput } from "@open-mercato/ui/backend/inputs/ComboboxInput";
+import { apiCall } from "@open-mercato/ui/backend/utils/apiCall";
+import { raiseCrudError } from "@open-mercato/ui/backend/utils/serverErrors";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
+import { useLocale, useT } from "@open-mercato/shared/lib/i18n/context";
+import { StatusBadge } from "@open-mercato/ui/primitives/status-badge";
+import { Boxes, Package, Route, ShieldCheck, Warehouse as WarehouseIcon, X } from "lucide-react";
+import { E } from "../../../../generated/entities.ids.generated.js";
+import {
+  createInventoryDateTimeFormatter,
+  createInventoryQuantityFormatter,
+  formatCatalogVariantLabel,
+  formatInventoryDateTime,
+  formatInventoryQuantity,
+  formatReservationSourceLabel,
+  inventoryMovementTypeLabel,
+  inventoryReferenceTypeLabel,
+  inventoryReservationSourceTypeLabel,
+  inventoryReservationStatusLabel
+} from "../../lib/inventoryDisplayUi.js";
+import { parseInventoryQuantity } from "../../lib/inventoryMutationUi.js";
+import { ImportInventoryDialog } from "./ImportInventoryDialog.js";
+import { InventoryOperationsSection } from "./InventoryOperationsSection.js";
+import { MoveInventoryDialog } from "./MoveInventoryDialog.js";
+import { ReceiveInventoryDialog } from "./ReceiveInventoryDialog.js";
+import { ReleaseReservationDialog } from "./ReleaseReservationDialog.js";
+import {
+  useWmsInventoryMutationAccess
+} from "./useWmsInventoryMutationAccess.js";
+import { Button } from "@open-mercato/ui/primitives/button";
+import {
+  loadCatalogVariantOptions,
+  loadWarehouseOptions,
+  resolveCatalogVariantLabel,
+  resolveWarehouseLabel
+} from "./inventoryMutationLoaders.js";
+import { mergeLabelCacheEntries } from "./wmsLookupLoaders.js";
+import {
+  useWmsInventoryScopeFromSearchParams
+} from "./useWmsInventoryScopeFromSearchParams.js";
+function formatVariantLabel(row) {
+  return formatCatalogVariantLabel(row);
+}
+const movementStatusMap = {
+  receipt: "success",
+  return_receive: "success",
+  adjust: "warning",
+  transfer: "info",
+  pick: "info",
+  pack: "info",
+  cycle_count: "neutral",
+  putaway: "info",
+  ship: "success"
+};
+const reservationStatusMap = {
+  active: "info",
+  released: "neutral",
+  fulfilled: "success"
+};
+function useInventoryDisplayFormatters() {
+  const locale = useLocale();
+  const quantityFormatter = React.useMemo(
+    () => createInventoryQuantityFormatter(locale),
+    [locale]
+  );
+  const dateTimeFormatter = React.useMemo(
+    () => createInventoryDateTimeFormatter(locale),
+    [locale]
+  );
+  return { quantityFormatter, dateTimeFormatter };
+}
+function formatWarehouseLabel(row) {
+  return row.warehouse_name?.trim() || row.warehouse_code?.trim() || row.warehouse_id || "\u2014";
+}
+function formatLocationLabel(row, prefix) {
+  const code = String(row[`${prefix}_code`] ?? "").trim();
+  if (code) return code;
+  const id = row[`${prefix}_id`];
+  return typeof id === "string" && id ? id : "\u2014";
+}
+function SectionCard({
+  title,
+  description,
+  icon,
+  children
+}) {
+  return /* @__PURE__ */ jsxs("section", { className: "rounded-lg border bg-card p-5 text-card-foreground shadow-sm", children: [
+    /* @__PURE__ */ jsxs("div", { className: "mb-4 flex items-start gap-3", children: [
+      /* @__PURE__ */ jsx("div", { className: "rounded-md border bg-muted/40 p-2 text-muted-foreground", children: icon }),
+      /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+        /* @__PURE__ */ jsx("h2", { className: "text-xl font-semibold", children: title }),
+        /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: description })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "overflow-x-auto", children })
+  ] });
+}
+function buildInventoryQuery(search, page, pageSize, sorting, scope) {
+  const sortCol = sorting[0];
+  const params = new URLSearchParams({
+    page: String(page),
+    pageSize: String(pageSize),
+    sortField: sortCol ? sortCol.id : "updatedAt",
+    sortDir: sortCol ? sortCol.desc ? "desc" : "asc" : "desc"
+  });
+  if (search.trim()) params.set("search", search.trim());
+  if (scope.warehouseId.trim()) params.set("warehouseId", scope.warehouseId.trim());
+  if (scope.variantId.trim()) params.set("catalogVariantId", scope.variantId.trim());
+  if (scope.lotId.trim()) params.set("lotId", scope.lotId.trim());
+  if (scope.lowStock) params.set("lowStock", scope.lowStock);
+  return params.toString();
+}
+function InventoryDataTableSection({
+  sectionQueryKey,
+  endpoint,
+  titleKey,
+  titleFallback,
+  descriptionKey,
+  descriptionFallback,
+  errorKey,
+  errorFallback,
+  searchKey,
+  searchFallback,
+  emptyTitleKey,
+  emptyTitleFallback,
+  emptyDescriptionKey,
+  emptyDescriptionFallback,
+  tableId,
+  entityId,
+  icon,
+  columns,
+  rowActions,
+  warehouseId = "",
+  variantId = "",
+  lotId = "",
+  lowStock = null,
+  extraParams,
+  toolbarActions,
+  emptyStateAction
+}) {
+  const t = useT();
+  const [page, setPage] = React.useState(1);
+  const [search, setSearch] = React.useState("");
+  const [sorting, setSorting] = React.useState([]);
+  const handleSortingChange = React.useCallback((nextSorting) => {
+    setSorting(nextSorting);
+    setPage(1);
+  }, []);
+  const params = React.useMemo(() => {
+    const base = buildInventoryQuery(search, page, 20, sorting, {
+      warehouseId,
+      variantId,
+      lotId,
+      lowStock
+    });
+    if (!extraParams || Object.keys(extraParams).length === 0) return base;
+    const urlParams = new URLSearchParams(base);
+    for (const [key, value] of Object.entries(extraParams)) {
+      urlParams.set(key, value);
+    }
+    return urlParams.toString();
+  }, [extraParams, lowStock, lotId, page, search, sorting, variantId, warehouseId]);
+  React.useEffect(() => {
+    setPage(1);
+  }, [warehouseId, variantId, lotId, lowStock]);
+  const query = useQuery({
+    queryKey: ["wms-inventory-console", sectionQueryKey, params],
+    queryFn: async () => {
+      const call = await apiCall(`${endpoint}?${params}`);
+      if (!call.ok) {
+        await raiseCrudError(call.response, t(errorKey, errorFallback));
+      }
+      return call.result ?? { items: [], total: 0, totalPages: 1 };
+    }
+  });
+  return /* @__PURE__ */ jsx(
+    SectionCard,
+    {
+      title: t(titleKey, titleFallback),
+      description: t(descriptionKey, descriptionFallback),
+      icon,
+      children: /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          embedded: true,
+          title: t(titleKey, titleFallback),
+          columns,
+          data: query.data?.items ?? [],
+          isLoading: query.isLoading,
+          error: query.isError ? t(errorKey, errorFallback) : null,
+          entityId,
+          searchValue: search,
+          onSearchChange: (value) => {
+            setSearch(value);
+            setPage(1);
+          },
+          searchPlaceholder: t(searchKey, searchFallback),
+          pagination: {
+            page,
+            pageSize: 20,
+            total: query.data?.total ?? 0,
+            totalPages: query.data?.totalPages ?? 1,
+            onPageChange: setPage
+          },
+          perspective: { tableId },
+          sortable: true,
+          manualSorting: true,
+          sorting,
+          onSortingChange: handleSortingChange,
+          rowActions,
+          emptyState: /* @__PURE__ */ jsx(
+            EmptyState,
+            {
+              title: t(emptyTitleKey, emptyTitleFallback),
+              description: t(emptyDescriptionKey, emptyDescriptionFallback),
+              actions: emptyStateAction
+            }
+          ),
+          actions: toolbarActions
+        }
+      )
+    }
+  );
+}
+function InventoryScopeBar({
+  warehouseId,
+  variantId,
+  onWarehouseChange,
+  onVariantChange
+}) {
+  const t = useT();
+  const [warehouseLabelCache, setWarehouseLabelCache] = React.useState({});
+  const [variantLabelCache, setVariantLabelCache] = React.useState({});
+  const warehouseLabelCacheRef = React.useRef(warehouseLabelCache);
+  warehouseLabelCacheRef.current = warehouseLabelCache;
+  const variantLabelCacheRef = React.useRef(variantLabelCache);
+  variantLabelCacheRef.current = variantLabelCache;
+  React.useEffect(() => {
+    if (!warehouseId.trim() || warehouseLabelCacheRef.current[warehouseId]) return;
+    let cancelled = false;
+    void resolveWarehouseLabel(warehouseId).then((label) => {
+      if (cancelled || !label) return;
+      setWarehouseLabelCache((c) => ({ ...c, [warehouseId]: label }));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [warehouseId]);
+  React.useEffect(() => {
+    if (!variantId.trim() || variantLabelCacheRef.current[variantId]) return;
+    let cancelled = false;
+    void resolveCatalogVariantLabel(variantId).then((label) => {
+      if (cancelled || !label) return;
+      setVariantLabelCache((c) => ({ ...c, [variantId]: label }));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [variantId]);
+  const loadWarehouseSuggestions = React.useCallback(async (query) => {
+    const options = await loadWarehouseOptions(query);
+    setWarehouseLabelCache((c) => mergeLabelCacheEntries(c, options));
+    return options.map((o) => ({ value: o.value, label: o.label }));
+  }, []);
+  const loadVariantSuggestions = React.useCallback(async (query) => {
+    const options = await loadCatalogVariantOptions(query);
+    setVariantLabelCache((c) => mergeLabelCacheEntries(c, options));
+    return options.map((o) => ({ value: o.value, label: o.label }));
+  }, []);
+  const hasScope = warehouseId.trim() || variantId.trim();
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-3 rounded-lg border bg-card px-4 py-3 shadow-sm", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(WarehouseIcon, { className: "size-4 shrink-0" }),
+      /* @__PURE__ */ jsx("span", { className: "text-sm font-medium", children: t("wms.backend.inventory.console.scopeBar.label", "Scope") })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "w-56", children: /* @__PURE__ */ jsx(
+      ComboboxInput,
+      {
+        value: warehouseId,
+        onChange: (next) => onWarehouseChange(next.trim()),
+        loadSuggestions: loadWarehouseSuggestions,
+        resolveLabel: (value) => warehouseLabelCache[value] ?? value,
+        placeholder: t("wms.backend.inventory.console.scopeBar.allWarehouses", "All warehouses"),
+        allowCustomValues: false,
+        clearable: true
+      }
+    ) }),
+    /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2 text-muted-foreground", children: /* @__PURE__ */ jsx(Package, { className: "size-4 shrink-0" }) }),
+    /* @__PURE__ */ jsx("div", { className: "w-56", children: /* @__PURE__ */ jsx(
+      ComboboxInput,
+      {
+        value: variantId,
+        onChange: (next) => onVariantChange(next.trim()),
+        loadSuggestions: loadVariantSuggestions,
+        resolveLabel: (value) => variantLabelCache[value] ?? value,
+        placeholder: t("wms.backend.inventory.console.scopeBar.allVariants", "All SKUs"),
+        allowCustomValues: false,
+        clearable: true
+      }
+    ) }),
+    hasScope ? /* @__PURE__ */ jsxs(
+      Button,
+      {
+        type: "button",
+        variant: "ghost",
+        size: "sm",
+        className: "h-auto px-2 py-1 text-xs",
+        onClick: () => {
+          onWarehouseChange("");
+          onVariantChange("");
+        },
+        children: [
+          /* @__PURE__ */ jsx(X, { className: "size-3" }),
+          t("wms.backend.inventory.console.scopeBar.clearAll", "Clear")
+        ]
+      }
+    ) : null
+  ] });
+}
+function InventoryBalancesSection({
+  access,
+  warehouseId = "",
+  variantId = "",
+  lotId = "",
+  lowStock = null
+}) {
+  const t = useT();
+  const { quantityFormatter } = useInventoryDisplayFormatters();
+  const [moveOpen, setMoveOpen] = React.useState(false);
+  const [movePreset, setMovePreset] = React.useState(null);
+  const [receiveOpen, setReceiveOpen] = React.useState(false);
+  const [importOpen, setImportOpen] = React.useState(false);
+  const openMoveDialog = React.useCallback((row) => {
+    setMovePreset(row);
+    setMoveOpen(true);
+  }, []);
+  const columns = React.useMemo(
+    () => [
+      {
+        accessorKey: "catalog_variant_id",
+        id: "catalogVariantId",
+        header: t("wms.backend.inventory.balances.columns.variant", "Variant"),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const variantId2 = row.original.catalog_variant_id?.trim();
+          const label = formatVariantLabel(row.original);
+          if (!variantId2) return label;
+          return /* @__PURE__ */ jsx(
+            Link,
+            {
+              href: `/backend/wms/sku/${encodeURIComponent(variantId2)}`,
+              className: "font-medium text-primary hover:underline",
+              children: label
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "warehouse_id",
+        id: "warehouseId",
+        header: t(
+          "wms.backend.inventory.balances.columns.warehouse",
+          "Warehouse"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => formatWarehouseLabel(row.original)
+      },
+      {
+        accessorKey: "location_id",
+        id: "locationId",
+        header: t(
+          "wms.backend.inventory.balances.columns.location",
+          "Location"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const locationId = row.original.location_id?.trim();
+          const label = formatLocationLabel(row.original, "location");
+          if (!locationId || label === "\u2014") return label;
+          return /* @__PURE__ */ jsx(
+            Link,
+            {
+              href: `/backend/wms/location/${encodeURIComponent(locationId)}`,
+              className: "font-medium text-primary hover:underline",
+              children: label
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "lot_id",
+        header: t("wms.backend.inventory.balances.columns.lot", "Lot"),
+        enableSorting: false,
+        cell: ({ row }) => {
+          const lotId2 = row.original.lot_id?.trim();
+          if (!lotId2) return "\u2014";
+          return /* @__PURE__ */ jsx(
+            Link,
+            {
+              href: `/backend/wms/lot/${encodeURIComponent(lotId2)}`,
+              className: "font-medium text-primary hover:underline",
+              children: t("wms.backend.inventory.balances.lotLink", "View lot")
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "quantity_available",
+        id: "quantityAvailable",
+        header: t(
+          "wms.backend.inventory.balances.columns.available",
+          "Available"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "tabular-nums", children: formatInventoryQuantity(row.original.quantity_available, quantityFormatter) })
+      },
+      {
+        accessorKey: "quantity_reserved",
+        id: "quantityReserved",
+        header: t(
+          "wms.backend.inventory.balances.columns.reserved",
+          "Reserved"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "tabular-nums", children: formatInventoryQuantity(row.original.quantity_reserved, quantityFormatter) })
+      },
+      {
+        accessorKey: "quantity_allocated",
+        id: "quantityAllocated",
+        header: t(
+          "wms.backend.inventory.balances.columns.allocated",
+          "Allocated"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "tabular-nums", children: formatInventoryQuantity(row.original.quantity_allocated, quantityFormatter) })
+      }
+    ],
+    [quantityFormatter, t]
+  );
+  const rowActions = React.useCallback(
+    (row) => {
+      if (!access.canMove) return null;
+      const available = parseInventoryQuantity(row.quantity_available);
+      if (available <= 0) return null;
+      return /* @__PURE__ */ jsx(
+        RowActions,
+        {
+          items: [
+            {
+              id: "move",
+              label: t("wms.backend.inventory.balances.actions.move", "Move"),
+              onSelect: () => openMoveDialog(row)
+            }
+          ]
+        }
+      );
+    },
+    [access.canMove, openMoveDialog, t]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      InventoryDataTableSection,
+      {
+        sectionQueryKey: "balances",
+        endpoint: "/api/wms/inventory/balances",
+        titleKey: "wms.backend.inventory.balances.title",
+        titleFallback: "Inventory balances",
+        descriptionKey: "wms.backend.inventory.balances.description",
+        descriptionFallback: "Current on-hand, reserved, allocated, and available quantities by bucket.",
+        errorKey: "wms.backend.inventory.errors.balances",
+        errorFallback: "Failed to load balances.",
+        searchKey: "wms.backend.inventory.balances.search",
+        searchFallback: "Search balances",
+        emptyTitleKey: "wms.backend.inventory.balances.empty.title",
+        emptyTitleFallback: "No balance buckets",
+        emptyDescriptionKey: "wms.backend.inventory.balances.empty.description",
+        emptyDescriptionFallback: "Balances appear after receipts, adjustments, or moves create inventory buckets.",
+        tableId: "wms.inventory.balances",
+        entityId: E.wms.inventory_balance,
+        icon: /* @__PURE__ */ jsx(Boxes, { className: "size-5" }),
+        columns,
+        rowActions,
+        warehouseId,
+        variantId,
+        lotId,
+        lowStock,
+        emptyStateAction: access.canReceive || access.canImport ? /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center justify-center gap-2", children: [
+          access.canReceive ? /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", size: "sm", onClick: () => setReceiveOpen(true), children: t("wms.backend.inventory.balances.empty.receive", "Receive stock") }) : null,
+          access.canImport ? /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", size: "sm", onClick: () => setImportOpen(true), children: t("wms.backend.inventory.balances.empty.importCsv", "Import CSV") }) : null
+        ] }) : null
+      }
+    ),
+    access.canReceive ? /* @__PURE__ */ jsx(
+      ReceiveInventoryDialog,
+      {
+        open: receiveOpen,
+        onOpenChange: setReceiveOpen,
+        access
+      }
+    ) : null,
+    access.canImport ? /* @__PURE__ */ jsx(ImportInventoryDialog, { open: importOpen, onOpenChange: setImportOpen, access }) : null,
+    access.canMove ? /* @__PURE__ */ jsx(
+      MoveInventoryDialog,
+      {
+        open: moveOpen,
+        onOpenChange: setMoveOpen,
+        access,
+        initialCatalogVariantId: movePreset?.catalog_variant_id ?? void 0,
+        initialWarehouseId: movePreset?.warehouse_id ?? void 0,
+        initialFromLocationId: movePreset?.location_id ?? void 0,
+        initialLotId: movePreset?.lot_id ?? void 0,
+        initialAvailable: movePreset ? parseInventoryQuantity(movePreset.quantity_available) : null,
+        lockSourceContext: true
+      }
+    ) : null
+  ] });
+}
+function InventoryReservationsSection({
+  access,
+  warehouseId = "",
+  variantId = "",
+  lotId = ""
+}) {
+  const t = useT();
+  const { quantityFormatter } = useInventoryDisplayFormatters();
+  const [releaseOpen, setReleaseOpen] = React.useState(false);
+  const [releasePreset, setReleasePreset] = React.useState(null);
+  const [activeOnly, setActiveOnly] = React.useState(true);
+  const { runMutation: runAllocateMutation, retryLastMutation: retryAllocate } = useGuardedMutation({
+    contextId: "wms-inventory-allocate"
+  });
+  const allocateMutationContext = React.useMemo(
+    () => ({ retryLastMutation: retryAllocate }),
+    [retryAllocate]
+  );
+  const handleAllocate = React.useCallback(
+    async (row) => {
+      if (!access.organizationId || !access.tenantId || !row.id) return;
+      const payload = {
+        organizationId: access.organizationId,
+        tenantId: access.tenantId,
+        reservationId: row.id
+      };
+      try {
+        await runAllocateMutation({
+          operation: async () => {
+            const call = await apiCall("/api/wms/inventory/allocate", {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify(payload)
+            });
+            if (!call.ok) await raiseCrudError(call.response, t("wms.backend.inventory.allocate.errors.submit", "Failed to allocate reservation."));
+            return call.result ?? {};
+          },
+          context: allocateMutationContext,
+          mutationPayload: payload
+        });
+        flash(t("wms.backend.inventory.allocate.flash.success", "Reservation allocated"), "success");
+      } catch {
+        flash(t("wms.backend.inventory.allocate.errors.submit", "Failed to allocate reservation."), "error");
+      }
+    },
+    [access.organizationId, access.tenantId, allocateMutationContext, runAllocateMutation, t]
+  );
+  const openReleaseDialog = React.useCallback((row) => {
+    setReleasePreset(row);
+    setReleaseOpen(true);
+  }, []);
+  const columns = React.useMemo(
+    () => [
+      {
+        accessorKey: "catalog_variant_id",
+        header: t(
+          "wms.backend.inventory.reservations.columns.variant",
+          "Variant"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => formatVariantLabel(row.original)
+      },
+      {
+        accessorKey: "warehouse_id",
+        header: t(
+          "wms.backend.inventory.reservations.columns.warehouse",
+          "Warehouse"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => formatWarehouseLabel(row.original)
+      },
+      {
+        accessorKey: "quantity",
+        header: t(
+          "wms.backend.inventory.reservations.columns.quantity",
+          "Quantity"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "tabular-nums", children: formatInventoryQuantity(row.original.quantity, quantityFormatter) })
+      },
+      {
+        accessorKey: "source_type",
+        header: t(
+          "wms.backend.inventory.reservations.columns.sourceType",
+          "Source type"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const sourceType = row.original.source_type?.trim();
+          if (!sourceType) return "\u2014";
+          return inventoryReservationSourceTypeLabel(sourceType, t);
+        }
+      },
+      {
+        accessorKey: "source_id",
+        header: t(
+          "wms.backend.inventory.reservations.columns.sourceId",
+          "Source"
+        ),
+        enableSorting: false,
+        cell: ({ row }) => formatReservationSourceLabel(row.original, t)
+      },
+      {
+        accessorKey: "status",
+        header: t(
+          "wms.backend.inventory.reservations.columns.status",
+          "Status"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const status = row.original.status?.trim();
+          if (!status) return "\u2014";
+          return /* @__PURE__ */ jsx(StatusBadge, { variant: reservationStatusMap[status] ?? "neutral", dot: true, children: inventoryReservationStatusLabel(status, t) });
+        }
+      }
+    ],
+    [quantityFormatter, t]
+  );
+  const rowActions = React.useCallback(
+    (row) => {
+      const status = (row.status ?? "").trim().toLowerCase();
+      const items = [];
+      if (access.canAllocate && status === "active") {
+        items.push({
+          id: "allocate",
+          label: t("wms.backend.inventory.reservations.actions.allocate", "Allocate"),
+          onSelect: () => void handleAllocate(row)
+        });
+      }
+      if (access.canRelease && status === "active") {
+        items.push({
+          id: "release",
+          label: t("wms.backend.inventory.reservations.actions.release", "Release"),
+          destructive: true,
+          onSelect: () => openReleaseDialog(row)
+        });
+      }
+      if (items.length === 0) return null;
+      return /* @__PURE__ */ jsx(RowActions, { items });
+    },
+    [access.canAllocate, access.canRelease, handleAllocate, openReleaseDialog, t]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      InventoryDataTableSection,
+      {
+        sectionQueryKey: "reservations",
+        endpoint: "/api/wms/inventory/reservations",
+        titleKey: "wms.backend.inventory.reservations.title",
+        titleFallback: "Inventory reservations",
+        descriptionKey: "wms.backend.inventory.reservations.description",
+        descriptionFallback: "Active and historical reservation records created by manual API calls or sales lifecycle automation.",
+        errorKey: "wms.backend.inventory.errors.reservations",
+        errorFallback: "Failed to load reservations.",
+        searchKey: "wms.backend.inventory.reservations.search",
+        searchFallback: "Search reservations",
+        emptyTitleKey: "wms.backend.inventory.reservations.empty.title",
+        emptyTitleFallback: "No reservations",
+        emptyDescriptionKey: "wms.backend.inventory.reservations.empty.description",
+        emptyDescriptionFallback: "Reservations show stock committed to orders, transfers, or manual holds.",
+        tableId: "wms.inventory.reservations",
+        entityId: E.wms.inventory_reservation,
+        icon: /* @__PURE__ */ jsx(ShieldCheck, { className: "size-5" }),
+        columns,
+        rowActions,
+        warehouseId,
+        variantId,
+        lotId,
+        extraParams: activeOnly ? { status: "active" } : void 0,
+        toolbarActions: /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: activeOnly ? "outline" : "ghost",
+            size: "sm",
+            onClick: () => setActiveOnly((prev) => !prev),
+            children: activeOnly ? t("wms.backend.inventory.reservations.filter.showAll", "Show all") : t("wms.backend.inventory.reservations.filter.activeOnly", "Active only")
+          }
+        )
+      }
+    ),
+    access.canRelease ? /* @__PURE__ */ jsx(
+      ReleaseReservationDialog,
+      {
+        open: releaseOpen,
+        onOpenChange: setReleaseOpen,
+        access,
+        reservation: releasePreset
+      }
+    ) : null
+  ] });
+}
+function InventoryMovementsSection({
+  warehouseId = "",
+  variantId = "",
+  lotId = ""
+}) {
+  const t = useT();
+  const { quantityFormatter, dateTimeFormatter } = useInventoryDisplayFormatters();
+  const columns = React.useMemo(
+    () => [
+      {
+        accessorKey: "type",
+        header: t("wms.backend.inventory.movements.columns.type", "Type"),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const type = row.original.type?.trim();
+          if (!type) return "\u2014";
+          return /* @__PURE__ */ jsx(StatusBadge, { variant: movementStatusMap[type] ?? "neutral", dot: true, children: inventoryMovementTypeLabel(type, t) });
+        }
+      },
+      {
+        accessorKey: "catalog_variant_id",
+        header: t(
+          "wms.backend.inventory.movements.columns.variant",
+          "Variant"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => formatVariantLabel(row.original)
+      },
+      {
+        accessorKey: "warehouse_id",
+        header: t(
+          "wms.backend.inventory.movements.columns.warehouse",
+          "Warehouse"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => formatWarehouseLabel(row.original)
+      },
+      {
+        accessorKey: "location_from_id",
+        header: t(
+          "wms.backend.inventory.movements.columns.locationFrom",
+          "From"
+        ),
+        enableSorting: false,
+        cell: ({ row }) => formatLocationLabel(row.original, "location_from")
+      },
+      {
+        accessorKey: "location_to_id",
+        header: t(
+          "wms.backend.inventory.movements.columns.locationTo",
+          "To"
+        ),
+        enableSorting: false,
+        cell: ({ row }) => formatLocationLabel(row.original, "location_to")
+      },
+      {
+        accessorKey: "quantity",
+        header: t(
+          "wms.backend.inventory.movements.columns.quantity",
+          "Quantity"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "tabular-nums", children: formatInventoryQuantity(row.original.quantity, quantityFormatter) })
+      },
+      {
+        accessorKey: "reference_type",
+        header: t(
+          "wms.backend.inventory.movements.columns.referenceType",
+          "Reference type"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const referenceType = row.original.reference_type?.trim();
+          if (!referenceType) return "\u2014";
+          return inventoryReferenceTypeLabel(referenceType, t);
+        }
+      },
+      {
+        accessorKey: "performed_at",
+        header: t(
+          "wms.backend.inventory.movements.columns.performedAt",
+          "Performed at"
+        ),
+        enableSorting: true,
+        cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: formatInventoryDateTime(
+          row.original.performed_at || row.original.received_at,
+          dateTimeFormatter
+        ) })
+      }
+    ],
+    [dateTimeFormatter, quantityFormatter, t]
+  );
+  return /* @__PURE__ */ jsx(
+    InventoryDataTableSection,
+    {
+      sectionQueryKey: "movements",
+      endpoint: "/api/wms/inventory/movements",
+      titleKey: "wms.backend.inventory.movements.title",
+      titleFallback: "Inventory movement ledger",
+      descriptionKey: "wms.backend.inventory.movements.description",
+      descriptionFallback: "Immutable movement history for receipts, transfers, adjustments, and cycle counts.",
+      errorKey: "wms.backend.inventory.errors.movements",
+      errorFallback: "Failed to load movements.",
+      searchKey: "wms.backend.inventory.movements.search",
+      searchFallback: "Search movement ledger",
+      emptyTitleKey: "wms.backend.inventory.movements.empty.title",
+      emptyTitleFallback: "No inventory movements",
+      emptyDescriptionKey: "wms.backend.inventory.movements.empty.description",
+      emptyDescriptionFallback: "Movement rows are created by receipts, reservations, moves, and reconciliation actions.",
+      tableId: "wms.inventory.movements",
+      entityId: E.wms.inventory_movement,
+      icon: /* @__PURE__ */ jsx(Route, { className: "size-5" }),
+      columns,
+      warehouseId,
+      variantId,
+      lotId
+    }
+  );
+}
+function WmsInventoryConsolePage() {
+  const access = useWmsInventoryMutationAccess();
+  const scopeFromUrl = useWmsInventoryScopeFromSearchParams();
+  const [warehouseId, setWarehouseId] = React.useState(scopeFromUrl.warehouseId);
+  const [variantId, setVariantId] = React.useState(scopeFromUrl.catalogVariantId);
+  const [lotId, setLotId] = React.useState(scopeFromUrl.lotId);
+  const [lowStock, setLowStock] = React.useState(scopeFromUrl.lowStock);
+  React.useEffect(() => {
+    setWarehouseId(scopeFromUrl.warehouseId);
+    setVariantId(scopeFromUrl.catalogVariantId);
+    setLotId(scopeFromUrl.lotId);
+    setLowStock(scopeFromUrl.lowStock);
+  }, [scopeFromUrl.catalogVariantId, scopeFromUrl.warehouseId, scopeFromUrl.lotId, scopeFromUrl.lowStock]);
+  const handleWarehouseChange = React.useCallback((next) => {
+    setWarehouseId(next);
+    setLotId("");
+    setLowStock(null);
+  }, []);
+  const handleVariantChange = React.useCallback((next) => {
+    setVariantId(next);
+    setLotId("");
+    setLowStock(null);
+  }, []);
+  return /* @__PURE__ */ jsx(Page, { children: /* @__PURE__ */ jsx(PageBody, { children: /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
+    /* @__PURE__ */ jsx(InventoryOperationsSection, { access }),
+    /* @__PURE__ */ jsx(
+      InventoryScopeBar,
+      {
+        warehouseId,
+        variantId,
+        onWarehouseChange: handleWarehouseChange,
+        onVariantChange: handleVariantChange
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      InventoryBalancesSection,
+      {
+        access,
+        warehouseId,
+        variantId,
+        lotId,
+        lowStock
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      InventoryReservationsSection,
+      {
+        access,
+        warehouseId,
+        variantId,
+        lotId
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      InventoryMovementsSection,
+      {
+        warehouseId,
+        variantId,
+        lotId
+      }
+    )
+  ] }) }) });
+}
+export {
+  InventoryBalancesSection,
+  InventoryMovementsSection,
+  InventoryReservationsSection,
+  WmsInventoryConsolePage as default
+};
+//# sourceMappingURL=WmsInventoryConsolePage.js.map