npm - @mohasinac/appkit - Versions diffs - 3.8.1 → 3.9.0 - Mend

@mohasinac/appkit 3.8.1 → 3.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (485) hide show

package/dist/_internal/client/theme/__tests__/ThemeProvider.test.js DELETED Viewed

@@ -1,109 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { render, screen, act } from "@testing-library/react";
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ThemeProvider, useTheme } from "../ThemeProvider";
-import { buildThemeRegistry } from "../buildRegistry";
-import { DEFAULT_DARK_THEME, DEFAULT_LIGHT_THEME, } from "../../../../tokens/themes";
-const MEDIA_QUERY = "(prefers-color-scheme: dark)";
-function mockMatchMedia(prefersDark) {
-    const listeners = [];
-    Object.defineProperty(window, "matchMedia", {
-        writable: true,
-        value: (query) => ({
-            matches: query === MEDIA_QUERY ? prefersDark : false,
-            media: query,
-            onchange: null,
-            addEventListener: (_event, cb) => listeners.push(cb),
-            removeEventListener: (_event, cb) => {
-                const idx = listeners.indexOf(cb);
-                if (idx !== -1)
-                    listeners.splice(idx, 1);
-            },
-            addListener: () => undefined,
-            removeListener: () => undefined,
-            dispatchEvent: () => true,
-        }),
-    });
-    return listeners;
-}
-function Probe() {
-    const { effectiveMode, activeTheme, preference } = useTheme();
-    return (_jsxs("div", { "data-testid": "probe", children: ["mode=", effectiveMode, " pref=", preference, " themeId=", activeTheme.id] }));
-}
-describe("ThemeProvider", () => {
-    beforeEach(() => {
-        window.localStorage.clear();
-        document.documentElement.removeAttribute("data-theme");
-        document.documentElement.className = "";
-        document.documentElement.style.cssText = "";
-    });
-    it("applies the default light theme when prefers-color-scheme is light", () => {
-        mockMatchMedia(false);
-        render(_jsx(ThemeProvider, { children: _jsx(Probe, {}) }));
-        expect(screen.getByTestId("probe").textContent).toContain(`themeId=${DEFAULT_LIGHT_THEME.id}`);
-        expect(document.documentElement.getAttribute("data-theme")).toBe(DEFAULT_LIGHT_THEME.id);
-    });
-    it("applies the default dark theme when prefers-color-scheme is dark", () => {
-        mockMatchMedia(true);
-        render(_jsx(ThemeProvider, { children: _jsx(Probe, {}) }));
-        expect(screen.getByTestId("probe").textContent).toContain(`themeId=${DEFAULT_DARK_THEME.id}`);
-        expect(document.documentElement.classList.contains("dark")).toBe(true);
-    });
-    it("toggleTheme flips preference between light and dark", () => {
-        mockMatchMedia(false);
-        const captured = {
-            current: null,
-        };
-        function Capture() {
-            captured.current = useTheme();
-            return null;
-        }
-        render(_jsx(ThemeProvider, { children: _jsx(Capture, {}) }));
-        expect(captured.current?.effectiveMode).toBe("light");
-        act(() => captured.current?.toggleTheme());
-        expect(captured.current?.effectiveMode).toBe("dark");
-        expect(captured.current?.preference).toBe("dark");
-    });
-    it("writes inline CSS variables from the active theme to <html>", () => {
-        mockMatchMedia(false);
-        render(_jsx(ThemeProvider, { children: _jsx(Probe, {}) }));
-        expect(document.documentElement.style.getPropertyValue("--appkit-color-primary")).toBe(DEFAULT_LIGHT_THEME.tokens["appkit-color-primary"]);
-    });
-    it("buildThemeRegistry falls back to built-ins for missing ids", () => {
-        const registry = buildThemeRegistry({
-            themes: [],
-            defaultLightThemeId: "missing",
-            defaultDarkThemeId: "missing-too",
-        });
-        expect(registry.defaultLightThemeId).toBe(DEFAULT_LIGHT_THEME.id);
-        expect(registry.defaultDarkThemeId).toBe(DEFAULT_DARK_THEME.id);
-    });
-    it("buildThemeRegistry merges admin records with built-ins", () => {
-        const adminTheme = {
-            id: "sunset-bright",
-            name: "Sunset Bright",
-            mode: "light",
-            builtIn: false,
-            tokens: { "appkit-color-primary": "#ff9900" },
-            gradients: {},
-        };
-        const registry = buildThemeRegistry({
-            themes: [adminTheme],
-            defaultLightThemeId: "sunset-bright",
-            defaultDarkThemeId: DEFAULT_DARK_THEME.id,
-        });
-        expect(registry.defaultLightThemeId).toBe("sunset-bright");
-        expect(registry.themes.find((t) => t.id === "sunset-bright")).toBeDefined();
-        expect(registry.themes.find((t) => t.id === DEFAULT_LIGHT_THEME.id)).toBeDefined();
-    });
-    it("useTheme throws outside the provider", () => {
-        // Suppress the expected console.error from React.
-        const spy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-        function Naked() {
-            useTheme();
-            return null;
-        }
-        expect(() => render(_jsx(Naked, {}))).toThrow(/useTheme/);
-        spy.mockRestore();
-    });
-});

package/dist/_internal/server/features/auctions/__tests__/service.test.d.ts DELETED Viewed

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

package/dist/_internal/server/features/auctions/__tests__/service.test.js DELETED Viewed

@@ -1,140 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("../../../../../repositories", () => ({
-    productRepository: {
-        findByIdOrSlug: vi.fn(),
-    },
-    bidRepository: {
-        findHighestBid: vi.fn(),
-    },
-}));
-import { computeMinBid, assertBidAmount, assertNotAuctionOwner, shouldAutoExtend, computeExtendedEndDate, } from "../service";
-import { productRepository } from "../../../../../repositories";
-import { BidTooLowError, BidOnOwnAuctionError, } from "../../../../shared/features/auctions/errors";
-import { AUCTION_MIN_BID_INCREMENT_PAISE, AUCTION_SNIPING_WINDOW_SECONDS, AUCTION_DEFAULT_EXTENSION_MINUTES, } from "../../../../shared/features/auctions/config";
-function makeAuction(overrides = {}) {
-    const future = new Date(Date.now() + 60 * 60 * 1000); // 1 hour from now
-    return {
-        id: "auction-test",
-        storeId: "store-owner",
-        listingType: "auction",
-        status: "published",
-        auctionEndDate: future,
-        autoExtendable: true,
-        auctionExtensionMinutes: AUCTION_DEFAULT_EXTENSION_MINUTES,
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe("computeMinBid", () => {
-    it("no current bid → returns startingBid + default increment", () => {
-        const product = makeAuction({ startingBid: 10000, currentBid: undefined });
-        expect(computeMinBid(product)).toBe(10000 + AUCTION_MIN_BID_INCREMENT_PAISE);
-    });
-    it("currentBid set → returns currentBid + default increment", () => {
-        const product = makeAuction({ currentBid: 50000 });
-        expect(computeMinBid(product)).toBe(50000 + AUCTION_MIN_BID_INCREMENT_PAISE);
-    });
-    it("uses the product's configured minBidIncrement when present", () => {
-        const product = makeAuction({ currentBid: 10000, minBidIncrement: 500 });
-        expect(computeMinBid(product)).toBe(10500);
-    });
-    it("no currentBid and no startingBid → 0 + increment", () => {
-        const product = makeAuction({ currentBid: undefined, startingBid: undefined });
-        expect(computeMinBid(product)).toBe(AUCTION_MIN_BID_INCREMENT_PAISE);
-    });
-});
-describe("assertBidAmount", () => {
-    it("bidAmount >= computeMinBid → no throw", () => {
-        const product = makeAuction({ currentBid: 10000 });
-        const min = computeMinBid(product);
-        expect(() => assertBidAmount(product, min)).not.toThrow();
-        expect(() => assertBidAmount(product, min + 100)).not.toThrow();
-    });
-    it("bidAmount < computeMinBid → throws BidTooLowError", () => {
-        const product = makeAuction({ currentBid: 10000 });
-        const min = computeMinBid(product);
-        expect(() => assertBidAmount(product, min - 1)).toThrow(BidTooLowError);
-    });
-    it("BidTooLowError contains the expected minimum", () => {
-        const product = makeAuction({ currentBid: 10000 });
-        const min = computeMinBid(product);
-        let caught;
-        try {
-            assertBidAmount(product, 0);
-        }
-        catch (e) {
-            caught = e;
-        }
-        expect(caught).toBeInstanceOf(BidTooLowError);
-        expect(caught?.message).toContain(String(min));
-    });
-});
-describe("assertNotAuctionOwner", () => {
-    it("bidderId !== storeId (owner) → no throw", () => {
-        const product = makeAuction({ storeId: "store-owner" });
-        expect(() => assertNotAuctionOwner(product, "different-user")).not.toThrow();
-    });
-    it("bidderId === storeId → throws BidOnOwnAuctionError", () => {
-        const product = makeAuction({ storeId: "store-owner" });
-        expect(() => assertNotAuctionOwner(product, "store-owner")).toThrow(BidOnOwnAuctionError);
-    });
-});
-describe("shouldAutoExtend", () => {
-    it("bid placed within sniping window → returns true", () => {
-        const nearlyEnd = new Date(Date.now() + (AUCTION_SNIPING_WINDOW_SECONDS - 30) * 1000);
-        const product = makeAuction({ auctionEndDate: nearlyEnd, autoExtendable: true });
-        expect(shouldAutoExtend(product)).toBe(true);
-    });
-    it("bid placed well outside sniping window → returns false", () => {
-        const farFuture = new Date(Date.now() + 60 * 60 * 1000); // 1 hour
-        const product = makeAuction({ auctionEndDate: farFuture, autoExtendable: true });
-        expect(shouldAutoExtend(product)).toBe(false);
-    });
-    it("autoExtendable=false → always returns false, even if within window", () => {
-        const nearlyEnd = new Date(Date.now() + 10 * 1000); // 10 seconds
-        const product = makeAuction({ auctionEndDate: nearlyEnd, autoExtendable: false });
-        expect(shouldAutoExtend(product)).toBe(false);
-    });
-});
-describe("computeExtendedEndDate", () => {
-    it("returns endDate + configured extensionMinutes", () => {
-        const end = new Date("2026-01-01T12:00:00Z");
-        const product = makeAuction({ auctionEndDate: end, auctionExtensionMinutes: 10 });
-        const result = computeExtendedEndDate(product);
-        expect(result.getTime()).toBe(end.getTime() + 10 * 60 * 1000);
-    });
-    it("uses AUCTION_DEFAULT_EXTENSION_MINUTES when not configured", () => {
-        const end = new Date("2026-01-01T12:00:00Z");
-        const product = makeAuction({ auctionEndDate: end, auctionExtensionMinutes: undefined });
-        const result = computeExtendedEndDate(product);
-        expect(result.getTime()).toBe(end.getTime() + AUCTION_DEFAULT_EXTENSION_MINUTES * 60 * 1000);
-    });
-});
-describe("assertAuctionActive (integration with repo mock)", async () => {
-    const { assertAuctionActive } = await import("../service");
-    it("auction exists + active → returns product", async () => {
-        const activeAuction = makeAuction();
-        productRepository.findByIdOrSlug.mockResolvedValue(activeAuction);
-        const result = await assertAuctionActive("auction-test");
-        expect(result).toBeDefined();
-    });
-    it("product not found → throws AuctionNotFoundError", async () => {
-        productRepository.findByIdOrSlug.mockResolvedValue(null);
-        const { AuctionNotFoundError } = await import("../../../../shared/features/auctions/errors");
-        await expect(assertAuctionActive("nonexistent")).rejects.toBeInstanceOf(AuctionNotFoundError);
-    });
-    it("product found but not an auction listing → throws AuctionNotFoundError", async () => {
-        const standardProduct = makeAuction({ listingType: "standard" });
-        productRepository.findByIdOrSlug.mockResolvedValue(standardProduct);
-        const { AuctionNotFoundError } = await import("../../../../shared/features/auctions/errors");
-        await expect(assertAuctionActive("auction-test")).rejects.toBeInstanceOf(AuctionNotFoundError);
-    });
-    it("auction exists but endDate in past → throws AuctionEndedError", async () => {
-        const expiredAuction = makeAuction({ auctionEndDate: new Date(Date.now() - 1000) });
-        productRepository.findByIdOrSlug.mockResolvedValue(expiredAuction);
-        const { AuctionEndedError } = await import("../../../../shared/features/auctions/errors");
-        await expect(assertAuctionActive("auction-test")).rejects.toBeInstanceOf(AuctionEndedError);
-    });
-});

package/dist/_internal/server/features/checkout/__tests__/actions.test.d.ts DELETED Viewed

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