@mohasinac/appkit 3.8.2 → 3.9.0

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

@@ -1,386 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
-import { DatabaseError } from "../../../../errors";
-const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = makeMockDb();
-const { mockEncryptPiiFields, mockDecryptPiiFields } = vi.hoisted(() => ({
-    mockEncryptPiiFields: vi.fn((d) => d),
-    mockDecryptPiiFields: vi.fn((d) => d),
-}));
-const { mockGetFirestoreCount } = vi.hoisted(() => ({
-    mockGetFirestoreCount: vi.fn().mockResolvedValue(0),
-}));
-vi.mock("../../../../providers/db-firebase/admin", () => ({
-    getAdminDb: () => db,
-}));
-vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        prepareForFirestore: (d) => d,
-        getFirestoreCount: mockGetFirestoreCount,
-    };
-});
-vi.mock("../../../../security", () => ({
-    encryptPiiFields: mockEncryptPiiFields,
-    decryptPiiFields: mockDecryptPiiFields,
-    ADDRESS_PII_FIELDS: ["fullName", "phone", "addressLine1"],
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-import { AddressesRepository } from "../addresses.repository";
-const repo = new AddressesRepository();
-function makeAddressDoc(overrides = {}) {
-    return {
-        id: "addr-1",
-        ownerType: "user",
-        ownerId: "user-1",
-        label: "Home",
-        fullName: "Ravi Kumar",
-        phone: "+91-9876543210",
-        addressLine1: "123 Main St",
-        city: "Mumbai",
-        state: "Maharashtra",
-        postalCode: "400001",
-        country: "IN",
-        isDefault: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-function makeAddressInput(overrides = {}) {
-    return {
-        label: "Home",
-        fullName: "Ravi Kumar",
-        phone: "+91-9876543210",
-        addressLine1: "123 Main St",
-        city: "Mumbai",
-        state: "Maharashtra",
-        postalCode: "400001",
-        country: "IN",
-        isDefault: false,
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    // Restore passthrough encryption mocks after clearAllMocks
-    mockEncryptPiiFields.mockImplementation((d) => d);
-    mockDecryptPiiFields.mockImplementation((d) => d);
-    db.collection.mockReturnValue(mockCollection);
-    mockCollection.doc.mockReturnValue(mockDocRef);
-    mockCollection.where.mockReturnValue(mockQuery);
-    mockQuery.where.mockReturnValue(mockQuery);
-    mockQuery.orderBy.mockReturnValue(mockQuery);
-    mockQuery.limit.mockReturnValue(mockQuery);
-    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-    mockDocRef.get.mockResolvedValue(makeSnap(null));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    mockDocRef.delete.mockResolvedValue(undefined);
-    db.batch.mockReturnValue(mockBatch);
-    mockGetFirestoreCount.mockResolvedValue(0);
-});
-// ---------------------------------------------------------------------------
-// listByOwner
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.listByOwner", () => {
-    it("returns addresses for the owner", async () => {
-        const addr = makeAddressDoc();
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: addr.id, data: addr }]));
-        const results = await repo.listByOwner("user", "user-1");
-        expect(results).toHaveLength(1);
-    });
-    it("queries with ownerType AND ownerId filters", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listByOwner("user", "user-1");
-        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "user");
-        expect(mockQuery.where).toHaveBeenCalledWith("ownerId", "==", "user-1");
-    });
-    it("orders results by createdAt descending", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listByOwner("user", "user-1");
-        expect(mockQuery.orderBy).toHaveBeenCalledWith("createdAt", "desc");
-    });
-    it("returns empty array when no addresses found", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const results = await repo.listByOwner("user", "nobody");
-        expect(results).toHaveLength(0);
-    });
-    it("returns store addresses when ownerType=store", async () => {
-        const addr = makeAddressDoc({ ownerType: "store", ownerId: "store-1" });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: addr.id, data: addr }]));
-        const results = await repo.listByOwner("store", "store-1");
-        expect(results).toHaveLength(1);
-        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "store");
-    });
-});
-// ---------------------------------------------------------------------------
-// listByOwnerType
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.listByOwnerType", () => {
-    it("queries only by ownerType (no ownerId filter)", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listByOwnerType("user");
-        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "user");
-        // Ensure ownerId filter NOT applied (only one where call at collection level)
-        const collectionWhereCalls = mockCollection.where.mock.calls.filter((c) => c[0] === "ownerId");
-        expect(collectionWhereCalls).toHaveLength(0);
-    });
-    it("applies the limit (default 500)", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listByOwnerType("store");
-        expect(mockQuery.limit).toHaveBeenCalledWith(500);
-    });
-    it("applies custom limit when provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listByOwnerType("store", 100);
-        expect(mockQuery.limit).toHaveBeenCalledWith(100);
-    });
-});
-// ---------------------------------------------------------------------------
-// countByOwner
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.countByOwner", () => {
-    it("returns count from getFirestoreCount", async () => {
-        mockGetFirestoreCount.mockResolvedValue(3);
-        const count = await repo.countByOwner("user", "user-1");
-        expect(count).toBe(3);
-    });
-    it("queries by ownerType AND ownerId", async () => {
-        await repo.countByOwner("user", "user-1");
-        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "user");
-        expect(mockQuery.where).toHaveBeenCalledWith("ownerId", "==", "user-1");
-    });
-    it("returns 0 when no addresses exist", async () => {
-        mockGetFirestoreCount.mockResolvedValue(0);
-        const count = await repo.countByOwner("user", "ghost-user");
-        expect(count).toBe(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// createForOwner
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.createForOwner", () => {
-    it("isDefault:false — no batch operations, docRef.set called", async () => {
-        const address = makeAddressDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
-        await repo.createForOwner("user", "user-1", makeAddressInput({ isDefault: false }));
-        expect(mockDocRef.set).toHaveBeenCalledOnce();
-        expect(mockBatch.update).not.toHaveBeenCalled();
-        expect(mockBatch.commit).not.toHaveBeenCalled();
-    });
-    it("isDefault:true with no existing defaults — no batch commit, docRef.set still called", async () => {
-        // clearDefaultFlag: empty snap → early return without batch
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        const address = makeAddressDoc({ isDefault: true });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
-        await repo.createForOwner("user", "user-1", makeAddressInput({ isDefault: true }));
-        expect(mockDocRef.set).toHaveBeenCalledOnce();
-        expect(mockBatch.commit).not.toHaveBeenCalled();
-    });
-    it("isDefault:true with existing defaults — clears them via batch before creating", async () => {
-        const existingDefault = makeAddressDoc({ isDefault: true, id: "addr-old" });
-        const existingSnap = makeSnap(existingDefault, "addr-old");
-        mockQuery.get.mockResolvedValue({ docs: [existingSnap], empty: false, size: 1 });
-        const newAddress = makeAddressDoc({ isDefault: true });
-        mockDocRef.get.mockResolvedValue(makeSnap(newAddress, "mock-doc-id"));
-        await repo.createForOwner("user", "user-1", makeAddressInput({ isDefault: true }));
-        expect(mockBatch.update).toHaveBeenCalledWith(existingSnap.ref, expect.objectContaining({ isDefault: false }));
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-        expect(mockDocRef.set).toHaveBeenCalledOnce();
-    });
-    it("sets ownerType and ownerId on the written document", async () => {
-        const address = makeAddressDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
-        await repo.createForOwner("store", "store-abc", makeAddressInput());
-        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ ownerType: "store", ownerId: "store-abc" }));
-    });
-    it("re-fetches the address after write to return consistent data", async () => {
-        const address = makeAddressDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
-        const result = await repo.createForOwner("user", "user-1", makeAddressInput());
-        // The re-fetch (findById) uses mockDocRef.get — result reflects that
-        expect(result).toBeDefined();
-        expect(mockDocRef.get).toHaveBeenCalled();
-    });
-    it("throws DatabaseError when re-fetch returns null (doc not readable after write)", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.createForOwner("user", "user-1", makeAddressInput())).rejects.toThrow(DatabaseError);
-    });
-    it("calls encryptPiiFields with the address data on write", async () => {
-        const address = makeAddressDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
-        await repo.createForOwner("user", "user-1", makeAddressInput({ fullName: "Jane Doe" }));
-        expect(mockEncryptPiiFields).toHaveBeenCalledWith(expect.objectContaining({ fullName: "Jane Doe" }), expect.arrayContaining(["fullName", "phone", "addressLine1"]));
-    });
-    it("uses an auto-generated Firestore ID (getCollection().doc() called without args)", async () => {
-        const address = makeAddressDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
-        await repo.createForOwner("user", "user-1", makeAddressInput());
-        // doc() called with no argument = auto-ID
-        const callsWithNoArg = mockCollection.doc.mock.calls.filter((args) => args.length === 0);
-        expect(callsWithNoArg).not.toHaveLength(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// updateForOwner
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.updateForOwner", () => {
-    it("throws DatabaseError when address not found", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.updateForOwner("user", "user-1", "addr-x", { label: "Work" })).rejects.toThrow(DatabaseError);
-    });
-    it("throws DatabaseError when ownerType does not match", async () => {
-        const address = makeAddressDoc({ ownerType: "store", ownerId: "store-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await expect(repo.updateForOwner("user", "user-1", "addr-1", { label: "Work" })).rejects.toThrow(DatabaseError);
-    });
-    it("throws DatabaseError when ownerId does not match", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-other" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await expect(repo.updateForOwner("user", "user-1", "addr-1", { label: "Work" })).rejects.toThrow(DatabaseError);
-    });
-    it("updates the address when ownership matches", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        await repo.updateForOwner("user", "user-1", "addr-1", { label: "Office" });
-        expect(mockDocRef.update).toHaveBeenCalled();
-    });
-    it("isDefault:true — clears existing defaults before updating", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        const existingDefault = makeAddressDoc({ isDefault: true, id: "addr-old" });
-        const existingSnap = makeSnap(existingDefault, "addr-old");
-        mockQuery.get.mockResolvedValue({ docs: [existingSnap], empty: false, size: 1 });
-        await repo.updateForOwner("user", "user-1", "addr-1", { isDefault: true });
-        expect(mockBatch.update).toHaveBeenCalledWith(existingSnap.ref, expect.objectContaining({ isDefault: false }));
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("isDefault:false — does NOT clear existing defaults", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await repo.updateForOwner("user", "user-1", "addr-1", { isDefault: false });
-        expect(mockBatch.commit).not.toHaveBeenCalled();
-    });
-    it("encrypts PII fields on update", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await repo.updateForOwner("user", "user-1", "addr-1", { fullName: "New Name" });
-        expect(mockEncryptPiiFields).toHaveBeenCalledWith(expect.objectContaining({ fullName: "New Name" }), expect.arrayContaining(["fullName", "phone", "addressLine1"]));
-    });
-});
-// ---------------------------------------------------------------------------
-// deleteForOwner
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.deleteForOwner", () => {
-    it("throws DatabaseError when address not found", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.deleteForOwner("user", "user-1", "addr-x")).rejects.toThrow(DatabaseError);
-    });
-    it("throws DatabaseError when address belongs to a different ownerId", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-other" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await expect(repo.deleteForOwner("user", "user-1", "addr-1")).rejects.toThrow(DatabaseError);
-    });
-    it("throws DatabaseError when address belongs to a different ownerType", async () => {
-        const address = makeAddressDoc({ ownerType: "store", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await expect(repo.deleteForOwner("user", "user-1", "addr-1")).rejects.toThrow(DatabaseError);
-    });
-    it("deletes the address when ownership matches", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await repo.deleteForOwner("user", "user-1", "addr-1");
-        expect(mockDocRef.delete).toHaveBeenCalledOnce();
-    });
-    it("does NOT delete address for a different store-owner", async () => {
-        const storeAddr = makeAddressDoc({ ownerType: "store", ownerId: "store-2" });
-        mockDocRef.get.mockResolvedValue(makeSnap(storeAddr, "addr-1"));
-        await expect(repo.deleteForOwner("store", "store-1", "addr-1")).rejects.toThrow(DatabaseError);
-        expect(mockDocRef.delete).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// setDefault
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.setDefault", () => {
-    it("throws DatabaseError when address not found", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.setDefault("user", "user-1", "addr-x")).rejects.toThrow(DatabaseError);
-    });
-    it("throws DatabaseError when address belongs to a different owner", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-other" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        await expect(repo.setDefault("user", "user-1", "addr-1")).rejects.toThrow(DatabaseError);
-    });
-    it("clears all existing defaults for the owner before setting the new one", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        const existingDefault = makeAddressDoc({ isDefault: true, id: "addr-old" });
-        const existingSnap = makeSnap(existingDefault, "addr-old");
-        mockQuery.get.mockResolvedValue({ docs: [existingSnap], empty: false, size: 1 });
-        await repo.setDefault("user", "user-1", "addr-1");
-        // clearDefaultFlag ran and batched the update
-        expect(mockBatch.update).toHaveBeenCalledWith(existingSnap.ref, expect.objectContaining({ isDefault: false }));
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("sets isDefault:true on the target address", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        await repo.setDefault("user", "user-1", "addr-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ isDefault: true }));
-    });
-    it("uses a batch for atomicity (clear + set in single WriteBatch)", async () => {
-        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
-        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
-        // Two existing defaults to clear
-        const s1 = makeSnap(makeAddressDoc({ isDefault: true, id: "old-1" }), "old-1");
-        const s2 = makeSnap(makeAddressDoc({ isDefault: true, id: "old-2" }), "old-2");
-        mockQuery.get.mockResolvedValue({ docs: [s1, s2], empty: false, size: 2 });
-        await repo.setDefault("user", "user-1", "addr-1");
-        expect(mockBatch.update).toHaveBeenCalledTimes(2);
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-});
-// ---------------------------------------------------------------------------
-// deleteAllForOwner
-// ---------------------------------------------------------------------------
-describe("AddressesRepository.deleteAllForOwner", () => {
-    it("returns 0 and does not start a batch when no addresses found", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        const count = await repo.deleteAllForOwner("user", "user-1");
-        expect(count).toBe(0);
-        expect(mockBatch.delete).not.toHaveBeenCalled();
-        expect(mockBatch.commit).not.toHaveBeenCalled();
-    });
-    it("batch-deletes all matching addresses and returns the count", async () => {
-        const s1 = makeSnap(makeAddressDoc({ id: "addr-1" }), "addr-1");
-        const s2 = makeSnap(makeAddressDoc({ id: "addr-2" }), "addr-2");
-        mockQuery.get.mockResolvedValue({ docs: [s1, s2], empty: false, size: 2 });
-        const count = await repo.deleteAllForOwner("user", "user-1");
-        expect(count).toBe(2);
-        expect(mockBatch.delete).toHaveBeenCalledWith(s1.ref);
-        expect(mockBatch.delete).toHaveBeenCalledWith(s2.ref);
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("queries by ownerType AND ownerId", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        await repo.deleteAllForOwner("store", "store-xyz");
-        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "store");
-        expect(mockQuery.where).toHaveBeenCalledWith("ownerId", "==", "store-xyz");
-    });
-    it("returns count matching the number of docs deleted", async () => {
-        const snaps = Array.from({ length: 5 }, (_, i) => makeSnap(makeAddressDoc({ id: `addr-${i}` }), `addr-${i}`));
-        mockQuery.get.mockResolvedValue({ docs: snaps, empty: false, size: 5 });
-        const count = await repo.deleteAllForOwner("user", "user-1");
-        expect(count).toBe(5);
-        expect(mockBatch.delete).toHaveBeenCalledTimes(5);
-    });
-});

package/dist/features/admin/components/AdminListingScaffold.d.ts

@@ -1,41 +0,0 @@
-import React from "react";
-import { type ListingLayoutProps } from "../../../ui";
-import type { AdminTableColumn } from "../types";
-export interface AdminListingScaffoldRow {
-    id: string;
-    primary: string;
-    secondary: string;
-    status: string;
-    updatedAt: string;
-    featured?: boolean;
-    isPromoted?: boolean;
-    isOnSale?: boolean;
-    isSold?: boolean;
-}
-interface AdminListingScaffoldProps extends ListingLayoutProps {
-    title: string;
-    subtitle: string;
-    actionLabel?: string;
-    actionHref?: string;
-    columns?: AdminTableColumn<AdminListingScaffoldRow>[];
-    getRowHref?: (row: AdminListingScaffoldRow) => string;
-    searchPlaceholder: string;
-    rows: AdminListingScaffoldRow[];
-    isLoading?: boolean;
-    errorMessage?: string;
-    emptyLabel?: string;
-    filterGroups?: ReadonlyArray<{
-        title: string;
-        options: ReadonlyArray<string>;
-        active?: string;
-        onSelect?: (option: string) => void;
-    }>;
-    activeFilters?: string[];
-    resultSummary?: string;
-    onSearch?: (query: string) => void;
-    searchValue?: string;
-    onClearFilters?: () => void;
-    renderRowActions?: (row: AdminListingScaffoldRow) => React.ReactNode;
-}
-export declare function AdminListingScaffold({ title, subtitle, actionLabel, actionHref, columns, getRowHref, searchPlaceholder, rows, isLoading, errorMessage, emptyLabel, filterGroups, activeFilters, resultSummary, onSearch, searchValue, onClearFilters, renderRowActions, children, headerSlot, filterContent, activeFiltersSlot, resultCountSlot, searchSlot, sortSlot, actionsSlot, ...props }: AdminListingScaffoldProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/features/admin/components/AdminListingScaffold.js

@@ -1,68 +0,0 @@
-"use client";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { Button, Div, Input, ListingLayout, Span, Text, } from "../../../ui";
-import { AdminPageHeader } from "./AdminPageHeader";
-import { DataTable } from "./DataTable";
-const DEFAULT_FILTER_GROUPS = [
-    {
-        title: "Status",
-        options: ["Active", "Draft", "Archived"],
-    },
-    {
-        title: "Updated",
-        options: ["Last 7 days", "This month", "Needs review"],
-    },
-];
-function buildColumns() {
-    return [
-        {
-            key: "primary",
-            header: "Item",
-            sortable: true,
-            render: (row) => (_jsxs(Div, { className: "space-y-1", children: [_jsx(Text, { className: "font-semibold text-zinc-900 dark:text-zinc-100", children: row.primary }), _jsx(Text, { className: "text-xs text-zinc-500 dark:text-zinc-400", children: row.secondary })] })),
-        },
-        {
-            key: "status",
-            header: "Status",
-            sortable: true,
-            className: "w-40",
-            render: (row) => (_jsx(Span, { className: "inline-flex rounded-full bg-primary-50 px-2.5 py-1 text-xs font-medium text-primary-800 dark:bg-secondary-900/30 dark:text-secondary-300", children: row.status })),
-        },
-        {
-            key: "updatedAt",
-            header: "Updated",
-            sortable: true,
-            className: "w-40",
-            render: (row) => (_jsx(Text, { className: "text-sm text-zinc-600 dark:text-zinc-300", children: row.updatedAt })),
-        },
-    ];
-}
-function renderFilterContent(groups = DEFAULT_FILTER_GROUPS) {
-    return (_jsx(Div, { className: "space-y-5", children: groups.map((group) => (_jsxs(Div, { className: "space-y-2", children: [_jsx(Text, { className: "text-xs font-semibold uppercase tracking-[0.18em] text-zinc-500 dark:text-zinc-400", children: group.title }), _jsx(Div, { className: "flex flex-wrap gap-2", children: group.options.map((option) => (_jsx(Button, { type: "button", variant: group.active === option ? "primary" : "outline", size: "sm", className: "rounded-full", onClick: () => group.onSelect?.(option), children: option }, `${group.title}-${option}`))) })] }, group.title))) }));
-}
-function renderActiveFilters(activeFilters) {
-    if (!activeFilters || activeFilters.length === 0) {
-        return null;
-    }
-    return (_jsx(Div, { className: "mb-4 flex flex-wrap gap-2", children: activeFilters.map((filter) => (_jsx(Span, { className: "inline-flex rounded-full border border-zinc-200 bg-white px-3 py-1 text-xs font-medium text-zinc-600 dark:border-slate-700 dark:bg-slate-900 dark:text-zinc-300", children: filter }, filter))) }));
-}
-export function AdminListingScaffold({ title, subtitle, actionLabel, actionHref, columns, getRowHref, searchPlaceholder, rows, isLoading, errorMessage, emptyLabel, filterGroups, activeFilters, resultSummary, onSearch, searchValue, onClearFilters, renderRowActions, children, headerSlot, filterContent, activeFiltersSlot, resultCountSlot, searchSlot, sortSlot, actionsSlot, ...props }) {
-    const [localSearch, setLocalSearch] = React.useState(searchValue ?? "");
-    const hasChildren = React.Children.count(children) > 0;
-    return (_jsx(ListingLayout, { ...props, portal: "admin", headerSlot: headerSlot ?? (_jsx(AdminPageHeader, { title: title, subtitle: subtitle, actionLabel: actionLabel, onAction: () => undefined, themeConfig: {
-                gradient: "rounded-3xl border border-zinc-200 bg-gradient-to-r from-white to-zinc-50 dark:border-slate-800 dark:from-slate-950 dark:to-slate-900",
-                titleClass: "text-3xl font-bold text-zinc-950 dark:text-zinc-50",
-                subtitleClass: "text-sm text-zinc-600 dark:text-zinc-300",
-                spacingClass: "space-y-1.5",
-            } })), filterContent: filterContent ?? renderFilterContent(filterGroups), activeFiltersSlot: activeFiltersSlot ?? renderActiveFilters(activeFilters), resultCountSlot: resultCountSlot ?? (_jsx(Text, { className: "text-sm text-zinc-600 dark:text-zinc-300", children: resultSummary ?? `Showing ${rows.length} items` })), searchSlot: searchSlot ?? (_jsx(Input, { value: localSearch, placeholder: searchPlaceholder, "aria-label": searchPlaceholder, className: "min-w-[240px]", onChange: (e) => {
-                setLocalSearch(e.target.value);
-            }, onKeyDown: (e) => {
-                if (e.key === "Enter") {
-                    onSearch?.(localSearch);
-                }
-            } })), sortSlot: sortSlot ?? (_jsx(Button, { type: "button", variant: "outline", size: "sm", children: "Newest first" })), actionsSlot: actionsSlot ??
-            (actionLabel ? (actionHref ? (_jsx(Button, { type: "button", variant: "primary", size: "sm", onClick: () => {
-                    window.location.href = actionHref;
-                }, children: actionLabel })) : (_jsx(Button, { type: "button", variant: "primary", size: "sm", children: actionLabel }))) : undefined), filterActiveCount: activeFilters?.length ?? 0, filterPendingCount: 0, errorSlot: errorMessage ? (_jsx(Div, { className: "rounded-xl border border-error/20 bg-error-surface px-4 py-3 text-sm text-error", children: errorMessage })) : undefined, children: hasChildren ? (children) : (_jsx(DataTable, { columns: columns ?? buildColumns(), rows: rows, isLoading: isLoading, emptyLabel: emptyLabel, getRowHref: getRowHref, renderRowActions: renderRowActions })) }));
-}

package/dist/features/admin/components/QuickActionsPanel.d.ts

@@ -1,15 +0,0 @@
-import React from "react";
-export interface QuickActionItem {
-    id: string;
-    label: string;
-    href?: string;
-    icon?: React.ReactNode;
-    onClick?: () => void;
-}
-export interface QuickActionsPanelProps {
-    title?: string;
-    actions: QuickActionItem[];
-    renderAction?: (action: QuickActionItem) => React.ReactNode;
-    className?: string;
-}
-export declare function QuickActionsPanel({ title, actions, renderAction, className, }: QuickActionsPanelProps): React.JSX.Element;

package/dist/features/admin/components/QuickActionsPanel.js

@@ -1,5 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Button, Div, Heading, Row, TextLink } from "../../../ui";
-export function QuickActionsPanel({ title, actions, renderAction, className = "", }) {
-    return (_jsxs(Div, { className: className, children: [title && (_jsx(Heading, { level: 3, className: "mb-4", children: title })), _jsx(Div, { layout: "grid", gap: "4", className: "grid-cols-1 md:grid-cols-3", children: actions.map((action) => (_jsx(Div, { children: renderAction ? (renderAction(action)) : action.onClick ? (_jsx(Button, { type: "button", variant: "outline", onClick: action.onClick, rounded: "lg", paddingX: "sm", paddingY: "sm", textSize: "sm", className: "w-full", children: _jsxs(Row, { align: "center", justify: "start", gap: "sm", className: "w-full", children: [action.icon, action.label] }) })) : (_jsxs(TextLink, { variant: "bare", href: action.href ?? "#", rounded: "lg", paddingX: "sm", paddingY: "xs", size: "sm", layout: "inline-flex", align: "center", justify: "start", gap: "sm", className: "w-full border border-[var(--appkit-color-border)] bg-[var(--appkit-color-surface)] text-[var(--appkit-color-text)]", children: [action.icon, action.label] })) }, action.id))) })] }));
-}

package/dist/features/admin/repository/__tests__/notification.repository.test.d.ts

@@ -1 +0,0 @@
-export {};