@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/features/search/repository/__tests__/search.repository.test.js

@@ -0,0 +1,369 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { SearchRepository } from "../search.repository";
+function makePagedResult(overrides = {}) {
+    return {
+        data: [],
+        total: 0,
+        page: 1,
+        perPage: 24,
+        totalPages: 0,
+        ...overrides,
+    };
+}
+const mockFindAll = vi.fn().mockResolvedValue(makePagedResult());
+const repo = new SearchRepository({ findAll: mockFindAll });
+function captureFilters() {
+    const call = mockFindAll.mock.calls[0][0];
+    return call.filters;
+}
+function captureSieveQuery() {
+    return mockFindAll.mock.calls[0][0];
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindAll.mockResolvedValue(makePagedResult());
+});
+// ---------------------------------------------------------------------------
+// Mandatory status filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — mandatory status==published", () => {
+    it("always appends status==published as the last filter", async () => {
+        await repo.search({});
+        const filters = captureFilters();
+        expect(filters.split(",").at(-1)).toBe("status==published");
+    });
+    it("includes status==published even when no other filters given", async () => {
+        await repo.search({});
+        const filters = captureFilters();
+        expect(filters).toBe("status==published");
+    });
+    it("includes status==published alongside other filters", async () => {
+        await repo.search({ q: "charizard", category: "category-trading-cards" });
+        const filters = captureFilters();
+        expect(filters).toContain("status==published");
+    });
+    it("status==published appears exactly once regardless of query shape", async () => {
+        await repo.search({ q: "test", category: "cat-1", minRating: 4 });
+        const filters = captureFilters();
+        const occurrences = filters.split(",").filter((p) => p === "status==published").length;
+        expect(occurrences).toBe(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Text search filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — text query (q)", () => {
+    it("sets title_=<q> when q is provided", async () => {
+        await repo.search({ q: "charizard" });
+        expect(captureFilters()).toContain("title_=charizard");
+    });
+    it("does NOT add a title filter when q is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("title_=");
+    });
+    it("does NOT add a title filter when q is empty string", async () => {
+        await repo.search({ q: "" });
+        expect(captureFilters()).not.toContain("title_=");
+    });
+});
+// ---------------------------------------------------------------------------
+// Category filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — category", () => {
+    it("adds category==<slug> filter when category is provided", async () => {
+        await repo.search({ category: "category-trading-cards" });
+        expect(captureFilters()).toContain("category==category-trading-cards");
+    });
+    it("does NOT add category filter when category is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("category==");
+    });
+});
+// ---------------------------------------------------------------------------
+// Subcategory filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — subcategory", () => {
+    it("adds subcategory==<slug> filter when subcategory is provided", async () => {
+        await repo.search({ subcategory: "category-pokemon" });
+        expect(captureFilters()).toContain("subcategory==category-pokemon");
+    });
+    it("does NOT add subcategory filter when subcategory is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("subcategory==");
+    });
+});
+// ---------------------------------------------------------------------------
+// Price range filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — price range", () => {
+    it("adds price>=<min> filter when minPrice is provided", async () => {
+        await repo.search({ minPrice: 500 });
+        expect(captureFilters()).toContain("price>=500");
+    });
+    it("adds price<=<max> filter when maxPrice is provided", async () => {
+        await repo.search({ maxPrice: 10000 });
+        expect(captureFilters()).toContain("price<=10000");
+    });
+    it("adds both min and max when a price range is specified", async () => {
+        await repo.search({ minPrice: 100, maxPrice: 5000 });
+        const filters = captureFilters();
+        expect(filters).toContain("price>=100");
+        expect(filters).toContain("price<=5000");
+    });
+    it("does NOT add price filters when neither minPrice nor maxPrice provided", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("price");
+    });
+    it("adds price>=0 filter when minPrice is 0", async () => {
+        await repo.search({ minPrice: 0 });
+        expect(captureFilters()).toContain("price>=0");
+    });
+});
+// ---------------------------------------------------------------------------
+// Condition filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — condition", () => {
+    it("adds condition==<value> filter when condition is provided", async () => {
+        await repo.search({ condition: "mint" });
+        expect(captureFilters()).toContain("condition==mint");
+    });
+    it("does NOT add condition filter when condition is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("condition==");
+    });
+});
+// ---------------------------------------------------------------------------
+// listingType filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — listingType", () => {
+    it("adds listingType==auction filter for auction search", async () => {
+        await repo.search({ listingType: "auction" });
+        expect(captureFilters()).toContain("listingType==auction");
+    });
+    it("adds listingType==standard for standard search", async () => {
+        await repo.search({ listingType: "standard" });
+        expect(captureFilters()).toContain("listingType==standard");
+    });
+    it("adds listingType==pre-order for pre-order search", async () => {
+        await repo.search({ listingType: "pre-order" });
+        expect(captureFilters()).toContain("listingType==pre-order");
+    });
+    it("does NOT add listingType filter when listingType is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("listingType==");
+    });
+});
+// ---------------------------------------------------------------------------
+// In-stock filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — inStock", () => {
+    it("adds availableQuantity>0 filter when inStock: true", async () => {
+        await repo.search({ inStock: true });
+        expect(captureFilters()).toContain("availableQuantity>0");
+    });
+    it("does NOT add availableQuantity filter when inStock: false", async () => {
+        await repo.search({ inStock: false });
+        expect(captureFilters()).not.toContain("availableQuantity");
+    });
+    it("does NOT add availableQuantity filter when inStock is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("availableQuantity");
+    });
+});
+// ---------------------------------------------------------------------------
+// Minimum rating filter
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — minRating", () => {
+    it("adds averageRating>=<value> filter when minRating is provided", async () => {
+        await repo.search({ minRating: 4 });
+        expect(captureFilters()).toContain("averageRating>=4");
+    });
+    it("adds averageRating>=0 filter when minRating is 0", async () => {
+        await repo.search({ minRating: 0 });
+        expect(captureFilters()).toContain("averageRating>=0");
+    });
+    it("does NOT add averageRating filter when minRating is undefined", async () => {
+        await repo.search({});
+        expect(captureFilters()).not.toContain("averageRating");
+    });
+});
+// ---------------------------------------------------------------------------
+// All filters combined
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — combined filters", () => {
+    it("builds combined filter string for full-featured query", async () => {
+        const query = {
+            q: "pikachu",
+            category: "category-trading-cards",
+            subcategory: "category-pokemon",
+            minPrice: 100,
+            maxPrice: 5000,
+            condition: "near-mint",
+            listingType: "standard",
+            inStock: true,
+            minRating: 3,
+        };
+        await repo.search(query);
+        const filters = captureFilters();
+        expect(filters).toContain("title_=pikachu");
+        expect(filters).toContain("category==category-trading-cards");
+        expect(filters).toContain("subcategory==category-pokemon");
+        expect(filters).toContain("price>=100");
+        expect(filters).toContain("price<=5000");
+        expect(filters).toContain("condition==near-mint");
+        expect(filters).toContain("listingType==standard");
+        expect(filters).toContain("availableQuantity>0");
+        expect(filters).toContain("averageRating>=3");
+        expect(filters).toContain("status==published");
+        // status is always last
+        expect(filters.split(",").at(-1)).toBe("status==published");
+    });
+});
+// ---------------------------------------------------------------------------
+// Sorting
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — sort", () => {
+    it("defaults to sort: createdAt, order: asc when no sort specified", async () => {
+        await repo.search({});
+        const q = captureSieveQuery();
+        expect(q.sort).toBe("createdAt");
+        expect(q.order).toBe("asc");
+    });
+    it("ascending sort: sort='price', no leading dash → order: asc", async () => {
+        await repo.search({ sort: "price" });
+        const q = captureSieveQuery();
+        expect(q.sort).toBe("price");
+        expect(q.order).toBe("asc");
+    });
+    it("descending sort: sort='-price' → order: desc, field: price", async () => {
+        await repo.search({ sort: "-price" });
+        const q = captureSieveQuery();
+        expect(q.sort).toBe("price");
+        expect(q.order).toBe("desc");
+    });
+    it("descending sort: sort='-createdAt' → order: desc, field: createdAt", async () => {
+        await repo.search({ sort: "-createdAt" });
+        const q = captureSieveQuery();
+        expect(q.sort).toBe("createdAt");
+        expect(q.order).toBe("desc");
+    });
+    it("ascending sort: sort='averageRating' → order: asc, field: averageRating", async () => {
+        await repo.search({ sort: "averageRating" });
+        const q = captureSieveQuery();
+        expect(q.sort).toBe("averageRating");
+        expect(q.order).toBe("asc");
+    });
+});
+// ---------------------------------------------------------------------------
+// Pagination
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — pagination", () => {
+    it("defaults to page: 1 when not provided", async () => {
+        await repo.search({});
+        const q = captureSieveQuery();
+        expect(q.page).toBe(1);
+    });
+    it("defaults to perPage: 24 when pageSize not provided", async () => {
+        await repo.search({});
+        const q = captureSieveQuery();
+        expect(q.perPage).toBe(24);
+    });
+    it("forwards custom page and pageSize", async () => {
+        await repo.search({ page: 3, pageSize: 12 });
+        const q = captureSieveQuery();
+        expect(q.page).toBe(3);
+        expect(q.perPage).toBe(12);
+    });
+});
+// ---------------------------------------------------------------------------
+// Response shape
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — response shape", () => {
+    it("maps PagedResult to SearchResponse correctly", async () => {
+        mockFindAll.mockResolvedValue({
+            data: [{ id: "p-1", title: "Charizard" }],
+            total: 1,
+            page: 1,
+            perPage: 24,
+            totalPages: 1,
+        });
+        const result = await repo.search({ q: "charizard" });
+        expect(result.items).toHaveLength(1);
+        expect(result.total).toBe(1);
+        expect(result.page).toBe(1);
+        expect(result.pageSize).toBe(24);
+        expect(result.totalPages).toBe(1);
+    });
+    it("hasMore: true when page < totalPages", async () => {
+        mockFindAll.mockResolvedValue({
+            data: [],
+            total: 100,
+            page: 1,
+            perPage: 24,
+            totalPages: 5,
+        });
+        const result = await repo.search({});
+        expect(result.hasMore).toBe(true);
+    });
+    it("hasMore: false when page == totalPages", async () => {
+        mockFindAll.mockResolvedValue({
+            data: [],
+            total: 24,
+            page: 1,
+            perPage: 24,
+            totalPages: 1,
+        });
+        const result = await repo.search({});
+        expect(result.hasMore).toBe(false);
+    });
+    it("hasMore: false when page > totalPages (edge case)", async () => {
+        mockFindAll.mockResolvedValue({
+            data: [],
+            total: 0,
+            page: 2,
+            perPage: 24,
+            totalPages: 1,
+        });
+        const result = await repo.search({});
+        expect(result.hasMore).toBe(false);
+    });
+    it("q is empty string in response when no q provided", async () => {
+        const result = await repo.search({});
+        expect(result.q).toBe("");
+    });
+    it("q reflects the search term in response", async () => {
+        const result = await repo.search({ q: "pokemon" });
+        expect(result.q).toBe("pokemon");
+    });
+    it("returns empty items array when no results", async () => {
+        mockFindAll.mockResolvedValue(makePagedResult());
+        const result = await repo.search({ q: "nonexistent-product" });
+        expect(result.items).toEqual([]);
+        expect(result.total).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Filter string format
+// ---------------------------------------------------------------------------
+describe("SearchRepository.search — filter string format", () => {
+    it("joins multiple filters with commas", async () => {
+        await repo.search({ q: "test", category: "cat-1" });
+        const filters = captureFilters();
+        const parts = filters.split(",");
+        expect(parts.length).toBeGreaterThan(1);
+        // No empty segments (no stray commas)
+        expect(parts.every((p) => p.length > 0)).toBe(true);
+    });
+    it("single active filter + status produces exactly 2 comma-separated parts", async () => {
+        await repo.search({ category: "cat-1" });
+        const filters = captureFilters();
+        const parts = filters.split(",");
+        expect(parts).toHaveLength(2);
+        expect(parts[0]).toBe("category==cat-1");
+        expect(parts[1]).toBe("status==published");
+    });
+    it("empty query produces filter string with only status==published", async () => {
+        await repo.search({});
+        expect(captureFilters()).toBe("status==published");
+    });
+});

package/dist/features/search/schemas/index.d.ts

@@ -21,9 +21,9 @@ export declare const searchProductItemSchema: z.ZodObject<{
     isPromoted: z.ZodOptional<z.ZodBoolean>;
     slug: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     title: string;
     slug: string;
+    id: string;
     status?: string | undefined;
     currency?: string | undefined;
     featured?: boolean | undefined;
@@ -32,9 +32,9 @@ export declare const searchProductItemSchema: z.ZodObject<{
     price?: number | undefined;
     mainImage?: string | undefined;
 }, {
-    id: string;
     title: string;
     slug: string;
+    id: string;
     status?: string | undefined;
     currency?: string | undefined;
     featured?: boolean | undefined;

package/dist/features/seller/api/coupons/route.d.ts

@@ -12,6 +12,6 @@
  * export { sellerCouponsGET as GET } from "@mohasinac/feat-seller";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/seller/api/offers/route.d.ts

@@ -12,6 +12,6 @@
  * export { sellerOffersGET as GET } from "@mohasinac/feat-seller";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/seller/api/products/route.d.ts

@@ -12,6 +12,6 @@
  * export { sellerProductsGET as GET } from "@mohasinac/feat-seller";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/seller/api/store/route.d.ts

@@ -12,6 +12,6 @@
  * export { sellerStoreGET as GET } from "@mohasinac/feat-seller";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/seller/components/BarcodeField.d.ts

@@ -0,0 +1,17 @@
+export interface BarcodeFieldProps {
+    label?: string;
+    value: string;
+    onChange: (value: string) => void;
+    /** Called when the scanner fires Enter after rapid character input (< 50 ms between keys). */
+    onScan?: (value: string) => void;
+    placeholder?: string;
+    helperText?: string;
+    autoFocus?: boolean;
+    readOnly?: boolean;
+}
+/**
+ * Text field that detects USB/Bluetooth barcode scanner input.
+ * Scanners type characters rapidly (< 50 ms per keydown) then send Enter.
+ * onScan is called when Enter follows rapid input; manual typing is ignored.
+ */
+export declare function BarcodeField({ label, value, onChange, onScan, placeholder, helperText, autoFocus, readOnly, }: BarcodeFieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/seller/components/BarcodeField.js

@@ -0,0 +1,30 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useCallback } from "react";
+import { FieldInput } from "../../../ui/forms/FieldInput";
+import { Text } from "../../../ui/components/Typography";
+import { Stack } from "../../../ui/components/Layout";
+/**
+ * Text field that detects USB/Bluetooth barcode scanner input.
+ * Scanners type characters rapidly (< 50 ms per keydown) then send Enter.
+ * onScan is called when Enter follows rapid input; manual typing is ignored.
+ */
+export function BarcodeField({ label = "Barcode / Sticker ID", value, onChange, onScan, placeholder = "Scan or type barcode…", helperText, autoFocus, readOnly, }) {
+    const lastKeyTime = useRef(0);
+    const buffer = useRef("");
+    const handleKeyDown = useCallback((e) => {
+        const now = Date.now();
+        if (e.key === "Enter") {
+            e.preventDefault();
+            if (buffer.current) {
+                onScan?.(buffer.current);
+                buffer.current = "";
+            }
+            return;
+        }
+        const interval = now - lastKeyTime.current;
+        buffer.current = interval < 50 ? buffer.current + e.key : e.key;
+        lastKeyTime.current = now;
+    }, [onScan]);
+    return (_jsxs(Stack, { gap: "xs", children: [_jsx(FieldInput, { name: "barcodeId", label: label, type: "text", value: value, onChange: onChange, onKeyDown: handleKeyDown, placeholder: placeholder, autoFocus: autoFocus, readOnly: readOnly }), helperText && (_jsx(Text, { size: "xs", color: "muted", children: helperText }))] }));
+}

package/dist/features/seller/components/FulfillmentView.d.ts

@@ -0,0 +1,5 @@
+export interface FulfillmentViewProps {
+    currentUserId?: string;
+    currentUserName?: string;
+}
+export declare function FulfillmentView({ currentUserId, }: FulfillmentViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/seller/components/FulfillmentView.js

@@ -0,0 +1,120 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { Heading, Text } from "../../../ui/components/Typography";
+import { Stack, Row } from "../../../ui/components/Layout";
+import { Button } from "../../../ui/components/Button";
+import { Badge } from "../../../ui/components/Badge";
+import { apiClient } from "../../../http";
+import { SELLER_ENDPOINTS } from "../../../constants/api-endpoints";
+import { BarcodeField } from "./BarcodeField";
+import { normalizeError } from "../../../errors/normalize";
+import { useToast } from "../../../ui";
+function statusBadgeVariant(status) {
+    if (status === "confirmed")
+        return "warning";
+    if (status === "processing")
+        return "info";
+    if (status === "shipped")
+        return "success";
+    return "default";
+}
+export function FulfillmentView({ currentUserId, }) {
+    const [mode, setMode] = useState("scan");
+    const [orders, setOrders] = useState([]);
+    const [scanValue, setScanValue] = useState("");
+    const [scanResult, setScanResult] = useState(null);
+    const [scanError, setScanError] = useState(null);
+    const [filterMine, setFilterMine] = useState(false);
+    const [isLoadingOrders, setIsLoadingOrders] = useState(true);
+    const [isConfirming, setIsConfirming] = useState(false);
+    const [actionLoadingId, setActionLoadingId] = useState(null);
+    const { showToast } = useToast();
+    const fetchOrders = useCallback(async () => {
+        // toast-intentionally-silent: background data loader — stale list is kept on error
+        setIsLoadingOrders(true);
+        try {
+            const res = await apiClient.get(SELLER_ENDPOINTS.ORDERS_FULFILLMENT);
+            setOrders(res.orders ?? []);
+        }
+        catch {
+            // keep stale list on error
+        }
+        finally {
+            setIsLoadingOrders(false);
+        }
+    }, []);
+    useEffect(() => {
+        void fetchOrders();
+    }, [fetchOrders]);
+    const handleScan = useCallback(async (barcode) => {
+        setScanError(null);
+        setScanResult(null);
+        try {
+            const product = await apiClient.get(SELLER_ENDPOINTS.PRODUCTS_SCAN(barcode));
+            const matchedOrder = orders.find((o) => o.productId === product.id ||
+                o.items?.some((i) => i.productId === product.id));
+            if (!matchedOrder) {
+                setScanError(`No pending order found for barcode "${barcode}".`);
+                return;
+            }
+            setScanResult({ product, order: matchedOrder });
+        }
+        catch (err) {
+            setScanError(normalizeError(err).message);
+        }
+    }, [orders]);
+    const confirmPick = useCallback(async () => {
+        if (!scanResult)
+            return;
+        setIsConfirming(true);
+        try {
+            await apiClient.patch(SELLER_ENDPOINTS.ORDERS_BY_ID(scanResult.order.id), { markPicked: true });
+            setScanResult(null);
+            setScanValue("");
+            setScanError(null);
+            showToast("Order marked as picked!", "success");
+            await fetchOrders();
+        }
+        catch (err) {
+            setScanError(normalizeError(err).message);
+        }
+        finally {
+            setIsConfirming(false);
+        }
+    }, [scanResult, fetchOrders, showToast]);
+    const handleMarkPicked = useCallback(async (orderId) => {
+        setActionLoadingId(orderId + ":picked");
+        try {
+            await apiClient.patch(SELLER_ENDPOINTS.ORDERS_BY_ID(orderId), {
+                markPicked: true,
+            });
+            await fetchOrders();
+        }
+        finally {
+            setActionLoadingId(null);
+        }
+    }, [fetchOrders]);
+    const handleMarkPacked = useCallback(async (orderId) => {
+        setActionLoadingId(orderId + ":packed");
+        try {
+            await apiClient.patch(SELLER_ENDPOINTS.ORDERS_BY_ID(orderId), {
+                markPacked: true,
+            });
+            await fetchOrders();
+        }
+        finally {
+            setActionLoadingId(null);
+        }
+    }, [fetchOrders]);
+    const visibleOrders = filterMine
+        ? orders.filter((o) => o.assignedWorkerId === currentUserId)
+        : orders;
+    return (_jsxs(Stack, { gap: "md", padding: "md", children: [_jsxs(Row, { align: "center", justify: "between", gap: "sm", wrap: true, children: [_jsx(Heading, { level: 3, children: "Pick & Pack" }), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { onClick: () => setMode("scan"), variant: mode === "scan" ? "primary" : "secondary", size: "sm", children: "Scan Mode" }), _jsx(Button, { onClick: () => setMode("list"), variant: mode === "list" ? "primary" : "secondary", size: "sm", children: "List Mode" })] })] }), mode === "scan" && (_jsxs(Stack, { gap: "md", children: [_jsx(BarcodeField, { autoFocus: true, value: scanValue, onChange: setScanValue, onScan: handleScan, helperText: "Point scanner at an item sticker or type the barcode and press Enter." }), scanError && (_jsx(Text, { color: "error", size: "sm", children: scanError })), scanResult && (_jsxs(Stack, { surface: "card", padding: "md", rounded: "md", gap: "sm", children: [_jsx(Text, { size: "xs", color: "muted", children: "Scanned item" }), _jsx(Heading, { level: 5, children: scanResult.product.title ?? scanResult.product.id }), _jsxs(Row, { gap: "md", wrap: true, children: [_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "xs", color: "muted", children: "Order" }), _jsxs(Text, { size: "sm", weight: "medium", children: ["#", scanResult.order.id] })] }), _jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "xs", color: "muted", children: "Buyer" }), _jsx(Text, { size: "sm", weight: "medium", children: scanResult.order.userName })] }), _jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "xs", color: "muted", children: "Status" }), _jsx(Badge, { variant: statusBadgeVariant(scanResult.order.status), children: scanResult.order.status })] })] }), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { variant: "primary", onClick: confirmPick, isLoading: isConfirming, children: "Confirm Pick" }), _jsx(Button, { variant: "secondary", onClick: () => {
+                                            setScanResult(null);
+                                            setScanValue("");
+                                            setScanError(null);
+                                        }, children: "Cancel" })] })] })), !scanResult && !scanError && (_jsx(Text, { color: "muted", size: "sm", children: orders.length === 0 && !isLoadingOrders
+                            ? "No orders waiting — great work!"
+                            : `${orders.length} order${orders.length === 1 ? "" : "s"} in queue.` }))] })), mode === "list" && (_jsxs(Stack, { gap: "sm", children: [_jsxs(Row, { align: "center", gap: "sm", children: [_jsx(Button, { variant: filterMine ? "primary" : "secondary", size: "sm", onClick: () => setFilterMine((v) => !v), children: filterMine ? "Showing My Orders" : "My Orders" }), _jsx(Text, { size: "xs", color: "muted", children: isLoadingOrders ? "Loading…" : `${visibleOrders.length} order${visibleOrders.length === 1 ? "" : "s"}` })] }), visibleOrders.length === 0 && !isLoadingOrders && (_jsx(Text, { color: "muted", children: "No orders waiting \u2014 great work!" })), visibleOrders.map((order) => (_jsxs(Stack, { surface: "card", padding: "sm", rounded: "md", gap: "xs", children: [_jsxs(Row, { align: "center", gap: "xs", wrap: true, children: [_jsxs(Text, { size: "sm", weight: "medium", children: ["#", order.id] }), _jsx(Badge, { variant: statusBadgeVariant(order.status), children: order.status }), order.pickedAt && (_jsx(Badge, { variant: "success", children: "Picked" })), order.packedAt && (_jsx(Badge, { variant: "success", children: "Packed" }))] }), _jsxs(Text, { size: "xs", color: "muted", children: [order.userName, order.items && order.items.length > 0 && (_jsxs(_Fragment, { children: [" \u00B7 ", order.items.map((i) => i.productTitle).join(", ")] }))] }), order.assignedWorkerId && (_jsxs(Text, { size: "xs", color: "muted", children: ["Assigned: ", order.assignedWorkerId === currentUserId ? "Me" : order.assignedWorkerId] })), _jsxs(Row, { gap: "xs", children: [!order.pickedAt && (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => handleMarkPicked(order.id), isLoading: actionLoadingId === order.id + ":picked", children: "Mark Picked" })), order.pickedAt && !order.packedAt && (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => handleMarkPacked(order.id), isLoading: actionLoadingId === order.id + ":packed", children: "Mark Packed" }))] })] }, order.id)))] }))] }));
+}

package/dist/features/seller/components/PrintCenterView.d.ts

@@ -14,6 +14,7 @@ interface PrintCenterProduct {
     condition?: string;
     stockCount?: number;
     physicalLocation?: string;
+    barcodeId?: string;
 }
 interface PrintCenterOrder {
     id: string;
@@ -25,6 +26,7 @@ interface PrintCenterOrder {
         productName: string;
         quantity: number;
         price: number;
+        barcodeId?: string;
     }[];
     physicalLocation?: string;
 }
@@ -36,5 +38,5 @@ interface PrintCenterViewProps {
     initialProducts?: PrintCenterProduct[];
     initialOrders?: PrintCenterOrder[];
 }
-export declare function PrintCenterView({ store, brandName }: PrintCenterViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function PrintCenterView({ store, brandName, initialProducts, initialOrders, }: PrintCenterViewProps): import("react/jsx-runtime").JSX.Element;
 export {};