@mohasinac/appkit 2.4.11 → 2.5.1

package/dist/_internal/server/features/pre-orders/actions.js

@@ -0,0 +1,26 @@
+"use server";
+import { productRepository } from "../../../../repositories";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { reservePreOrderSchema } from "../../../shared/features/pre-orders/schema";
+import { assertPreOrderAvailable, computeDeposit } from "./service";
+import { ValidationError } from "../../../shared/errors/index";
+export async function reservePreOrderAction(input) {
+    const user = await requireRoleUser(["buyer", "seller", "admin"]);
+    const parsed = reservePreOrderSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid reservation input");
+    const { preOrderId, quantity } = parsed.data;
+    const product = await assertPreOrderAvailable(preOrderId, quantity);
+    const deposit = computeDeposit(product);
+    // Increment reservation count
+    await productRepository.update(preOrderId, {
+        preOrderCurrentCount: (product.preOrderCurrentCount ?? 0) + quantity,
+    });
+    return {
+        preOrderId,
+        buyerId: user.uid,
+        quantity,
+        depositAmount: deposit * quantity,
+        status: "pending_payment",
+    };
+}

package/dist/_internal/server/features/pre-orders/data.d.ts

@@ -0,0 +1,4 @@
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+import type { ProductFeatureDocument } from "../../../../features/products/schemas/product-features";
+export declare const getPreOrderForDetail: (slugOrId: string) => Promise<ProductDocument | null>;
+export declare const getProductFeaturesForPreOrder: (storeId: string | null) => Promise<ProductFeatureDocument[]>;

package/dist/_internal/server/features/pre-orders/data.js

@@ -0,0 +1,9 @@
+import { cache } from "react";
+import { productRepository } from "../../../../repositories";
+import { loadProductFeaturesForStore } from "../../../../features/products/repository/loadProductFeatures";
+export const getPreOrderForDetail = cache(async (slugOrId) => {
+    return (await productRepository.findByIdOrSlug(slugOrId).catch(() => undefined)) ?? null;
+});
+export const getProductFeaturesForPreOrder = cache(async (storeId) => {
+    return loadProductFeaturesForStore(storeId).catch(() => []);
+});

package/dist/_internal/server/features/pre-orders/index.d.ts

@@ -0,0 +1,5 @@
+export { getPreOrderForDetail, getProductFeaturesForPreOrder } from "./data";
+export { assertPreOrderAvailable, computeDeposit, isPreOrderOpen } from "./service";
+export { reservePreOrderAction } from "./actions";
+export { PRE_ORDERS_PAGE_SIZE, PRE_ORDER_DEFAULT_DEPOSIT_PERCENT, PRE_ORDER_MAX_QUANTITY_DEFAULT, } from "../../../shared/features/pre-orders/config";
+export { renderPreOrderOgImage, renderPreOrderOg, type PreOrderOgData } from "./og";

package/dist/_internal/server/features/pre-orders/index.js

@@ -0,0 +1,5 @@
+export { getPreOrderForDetail, getProductFeaturesForPreOrder } from "./data";
+export { assertPreOrderAvailable, computeDeposit, isPreOrderOpen } from "./service";
+export { reservePreOrderAction } from "./actions";
+export { PRE_ORDERS_PAGE_SIZE, PRE_ORDER_DEFAULT_DEPOSIT_PERCENT, PRE_ORDER_MAX_QUANTITY_DEFAULT, } from "../../../shared/features/pre-orders/config";
+export { renderPreOrderOgImage, renderPreOrderOg } from "./og";

package/dist/_internal/server/features/pre-orders/og.d.ts

@@ -0,0 +1,19 @@
+import type { ReactElement } from "react";
+export interface PreOrderOgData {
+    title: string;
+    releaseDateLabel?: string | null;
+    imageUrl?: string | null;
+}
+interface PreOrderDocLike {
+    title?: string | null;
+    preOrderReleaseDate?: Date | string | null;
+    mainImage?: string | null;
+    images?: (string | null | undefined)[] | null;
+}
+/** High-level OG renderer — accepts the raw pre-order document from `getPreOrderForDetail`. */
+export declare function renderPreOrderOg(doc: PreOrderDocLike | null | undefined, opts: {
+    siteName: string;
+    locale?: string;
+}): ReactElement;
+export declare function renderPreOrderOgImage(data: PreOrderOgData, siteName: string): ReactElement;
+export {};

package/dist/_internal/server/features/pre-orders/og.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** High-level OG renderer — accepts the raw pre-order document from `getPreOrderForDetail`. */
+export function renderPreOrderOg(doc, opts) {
+    const locale = opts.locale ?? "en-IN";
+    const release = doc?.preOrderReleaseDate
+        ? new Date(doc.preOrderReleaseDate)
+        : null;
+    const releaseDateLabel = release
+        ? `Ships ${release.toLocaleDateString(locale, { day: "numeric", month: "short", year: "numeric" })}`
+        : null;
+    return renderPreOrderOgImage({
+        title: doc?.title ?? "Pre-Order",
+        releaseDateLabel,
+        imageUrl: doc?.mainImage || doc?.images?.[0] || null,
+    }, opts.siteName);
+}
+export function renderPreOrderOgImage(data, siteName) {
+    const { title, releaseDateLabel, imageUrl } = data;
+    return (_jsxs("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: "#0f172a",
+            fontFamily: "sans-serif",
+            position: "relative",
+            overflow: "hidden",
+        }, children: [imageUrl && (_jsx("img", { src: imageUrl, alt: "", style: { position: "absolute", inset: 0, width: "100%", height: "100%", objectFit: "cover", opacity: 0.15 } })), _jsx("div", { style: {
+                    position: "absolute",
+                    inset: 0,
+                    background: "linear-gradient(135deg, rgba(15,23,42,0.95) 0%, rgba(15,23,42,0.8) 100%)",
+                } }), _jsxs("div", { style: {
+                    position: "relative",
+                    display: "flex",
+                    width: "100%",
+                    height: "100%",
+                    padding: "60px",
+                    gap: "48px",
+                    alignItems: "center",
+                }, children: [imageUrl && (_jsx("img", { src: imageUrl, alt: title, style: { width: 420, height: 420, objectFit: "contain", borderRadius: 16, flexShrink: 0 } })), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 24, flex: 1 }, children: [_jsxs("div", { style: { fontSize: 20, color: "#818cf8", fontWeight: 600, letterSpacing: 2, textTransform: "uppercase" }, children: [siteName, " \u00B7 Pre-Order"] }), _jsx("div", { style: {
+                                    fontSize: imageUrl ? 44 : 56,
+                                    fontWeight: 700,
+                                    color: "#f1f5f9",
+                                    lineHeight: 1.2,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 3,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: title }), releaseDateLabel && (_jsx("div", { style: { fontSize: 28, fontWeight: 600, color: "#818cf8" }, children: releaseDateLabel }))] })] })] }));
+}

package/dist/_internal/server/features/pre-orders/service.d.ts

@@ -0,0 +1,7 @@
+import type { ProductDocument } from "../../../shared/features/products/types";
+/** Assert a pre-order exists, is published, and has remaining capacity. */
+export declare function assertPreOrderAvailable(preOrderId: string, requestedQty?: number): Promise<ProductDocument>;
+/** Compute deposit amount in paise. */
+export declare function computeDeposit(product: ProductDocument): number;
+/** Determine if the pre-order is still open for new reservations. */
+export declare function isPreOrderOpen(product: ProductDocument): boolean;

package/dist/_internal/server/features/pre-orders/service.js

@@ -0,0 +1,30 @@
+import { productRepository } from "../../../../repositories";
+import { isPreOrderListing } from "../../../../features/products/utils/listing-type";
+import { PreOrderNotFoundError, PreOrderSoldOutError, PreOrderNotOpenError, } from "../../../shared/features/pre-orders/errors";
+/** Assert a pre-order exists, is published, and has remaining capacity. */
+export async function assertPreOrderAvailable(preOrderId, requestedQty = 1) {
+    const product = await productRepository.findByIdOrSlug(preOrderId).catch(() => null);
+    if (!product || !isPreOrderListing(product))
+        throw new PreOrderNotFoundError(preOrderId);
+    if (product.status !== "published")
+        throw new PreOrderNotOpenError(product.status);
+    const maxQty = product.preOrderMaxQuantity ?? Infinity;
+    const current = product.preOrderCurrentCount ?? 0;
+    if (current + requestedQty > maxQty)
+        throw new PreOrderSoldOutError(preOrderId);
+    return product;
+}
+/** Compute deposit amount in paise. */
+export function computeDeposit(product) {
+    if (product.preOrderDepositAmount)
+        return product.preOrderDepositAmount;
+    const percent = product.preOrderDepositPercent ?? 20;
+    return Math.round((product.price * percent) / 100);
+}
+/** Determine if the pre-order is still open for new reservations. */
+export function isPreOrderOpen(product) {
+    if (product.status !== "published")
+        return false;
+    const status = product.preOrderProductionStatus;
+    return status === "upcoming" || status === "in_production";
+}

package/dist/_internal/server/features/products/actions.d.ts

@@ -0,0 +1,7 @@
+export declare function createProductAction(input: unknown): Promise<import("../../../..").ProductDocument>;
+export declare function createAuctionAction(input: unknown): Promise<import("../../../..").ProductDocument>;
+export declare function createPreOrderAction(input: unknown): Promise<import("../../../..").ProductDocument>;
+export declare function updateProductAction(productId: string, input: unknown): Promise<import("../../../..").ProductDocument>;
+export declare function deleteProductAction(productId: string): Promise<void>;
+export declare function setProductStatusAction(input: unknown): Promise<import("../../../..").ProductDocument>;
+export declare function setProductFeaturedAction(input: unknown): Promise<import("../../../..").ProductDocument>;

package/dist/_internal/server/features/products/actions.js

@@ -0,0 +1,74 @@
+"use server";
+import { productRepository } from "../../../../repositories";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { productInputSchema, productUpdateSchema, auctionInputSchema, preOrderInputSchema, setFeaturedSchema, setStatusSchema, } from "../../../shared/features/products/schema";
+import { assertProductOwnership, assertStatusTransition } from "./service";
+import { ValidationError } from "../../../shared/errors/index";
+export async function createProductAction(input) {
+    const user = await requireRoleUser(["seller", "admin"]);
+    const parsed = productInputSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+    return productRepository.create({
+        ...parsed.data,
+        storeId: user.uid,
+        status: "draft",
+        listingType: "standard",
+        featured: false,
+    });
+}
+export async function createAuctionAction(input) {
+    const user = await requireRoleUser(["seller", "admin"]);
+    const parsed = auctionInputSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+    return productRepository.create({
+        ...parsed.data,
+        storeId: user.uid,
+        status: "draft",
+        listingType: "auction",
+        featured: false,
+    });
+}
+export async function createPreOrderAction(input) {
+    const user = await requireRoleUser(["seller", "admin"]);
+    const parsed = preOrderInputSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+    return productRepository.create({
+        ...parsed.data,
+        storeId: user.uid,
+        status: "draft",
+        listingType: "pre-order",
+        featured: false,
+    });
+}
+export async function updateProductAction(productId, input) {
+    const user = await requireRoleUser(["seller", "admin"]);
+    await assertProductOwnership(productId, user.uid);
+    const parsed = productUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+    return productRepository.update(productId, parsed.data);
+}
+export async function deleteProductAction(productId) {
+    const user = await requireRoleUser(["seller", "admin"]);
+    await assertProductOwnership(productId, user.uid);
+    return productRepository.delete(productId);
+}
+export async function setProductStatusAction(input) {
+    const user = await requireRoleUser(["seller", "admin"]);
+    const parsed = setStatusSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+    const product = await assertProductOwnership(parsed.data.productId, user.uid);
+    assertStatusTransition(product.status, parsed.data.status);
+    return productRepository.update(parsed.data.productId, { status: parsed.data.status });
+}
+export async function setProductFeaturedAction(input) {
+    await requireRoleUser("admin");
+    const parsed = setFeaturedSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid input");
+    return productRepository.update(parsed.data.productId, { featured: parsed.data.featured });
+}

package/dist/_internal/server/features/products/data.d.ts

@@ -0,0 +1,14 @@
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+/** Fetch a single product by slug or id, deduped per request. */
+export declare const getProductForDetail: (slugOrId: string) => Promise<ProductDocument | null>;
+/** Fetch the first page of approved reviews for a product, deduped per request. */
+export declare const getReviewsForProduct: (productId: string) => Promise<unknown[]>;
+/** Minimal product fields needed for sitemap generation. */
+export interface SitemapProduct {
+    slugOrId: string;
+    updatedAt: Date;
+    /** Canonical listing-kind discriminator (SB1-G — Phase 4 dropped booleans). */
+    listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle";
+}
+/** List all published products for sitemap generation. */
+export declare function listSitemapProducts(): Promise<SitemapProduct[]>;

package/dist/_internal/server/features/products/data.js

@@ -0,0 +1,48 @@
+import { cache } from "react";
+import { productRepository } from "../../../../repositories";
+import { reviewRepository } from "../../../../repositories";
+import { getAdminDb } from "../../../../providers/db-firebase";
+import { PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
+import { PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";
+// ---------------------------------------------------------------------------
+// Request-scoped cache — each function is deduplicated per RSC render tree.
+// Both generateMetadata() and the page component get the same promise.
+// ---------------------------------------------------------------------------
+/** Fetch a single product by slug or id, deduped per request. */
+export const getProductForDetail = cache(async (slugOrId) => {
+    return (await productRepository.findByIdOrSlug(slugOrId).catch(() => undefined)) ?? null;
+});
+/** Fetch the first page of approved reviews for a product, deduped per request. */
+export const getReviewsForProduct = cache(async (productId) => {
+    return reviewRepository.findApprovedByProduct(productId).catch(() => []);
+});
+/** List all published products for sitemap generation. */
+export async function listSitemapProducts() {
+    try {
+        const db = getAdminDb();
+        const snapshot = await db
+            .collection(PRODUCT_COLLECTION)
+            .where("status", "==", "published")
+            .select("slug", "id", "updatedAt", "listingType")
+            .limit(PRODUCTS_SITEMAP_LIMIT)
+            .get();
+        return snapshot.docs.map((doc) => {
+            const data = doc.data();
+            const rawListingType = data.listingType;
+            const listingType = rawListingType === "auction" ||
+                rawListingType === "pre-order" ||
+                rawListingType === "prize-draw" ||
+                rawListingType === "bundle"
+                ? rawListingType
+                : "standard";
+            return {
+                slugOrId: data.slug ?? doc.id,
+                updatedAt: data.updatedAt?.toDate?.() ?? new Date(),
+                listingType,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/_internal/server/features/products/index.d.ts

@@ -0,0 +1,5 @@
+export { getProductForDetail, getReviewsForProduct, listSitemapProducts, type SitemapProduct, } from "./data";
+export { assertProductOwnership, assertStatusTransition, assertInStock, effectivePrice, isAvailableForPurchase, } from "./service";
+export { createProductAction, createAuctionAction, createPreOrderAction, updateProductAction, deleteProductAction, setProductStatusAction, setProductFeaturedAction, } from "./actions";
+export { PRODUCTS_PAGE_SIZE, PRODUCTS_FEATURED_LIMIT, PRODUCTS_RELATED_LIMIT, PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";
+export { renderProductOgImage, renderProductOg, type ProductOgData, type OgOptions } from "./og";

package/dist/_internal/server/features/products/index.js

@@ -0,0 +1,5 @@
+export { getProductForDetail, getReviewsForProduct, listSitemapProducts, } from "./data";
+export { assertProductOwnership, assertStatusTransition, assertInStock, effectivePrice, isAvailableForPurchase, } from "./service";
+export { createProductAction, createAuctionAction, createPreOrderAction, updateProductAction, deleteProductAction, setProductStatusAction, setProductFeaturedAction, } from "./actions";
+export { PRODUCTS_PAGE_SIZE, PRODUCTS_FEATURED_LIMIT, PRODUCTS_RELATED_LIMIT, PRODUCTS_SITEMAP_LIMIT } from "../../../shared/features/products/config";
+export { renderProductOgImage, renderProductOg } from "./og";

package/dist/_internal/server/features/products/og.d.ts

@@ -0,0 +1,19 @@
+import type { ReactElement } from "react";
+export interface ProductOgData {
+    title: string;
+    price?: number | null;
+    imageUrl?: string | null;
+}
+export interface OgOptions {
+    siteName: string;
+}
+interface ProductDocLike {
+    title?: string | null;
+    price?: number | null;
+    mainImage?: string | null;
+    images?: (string | null | undefined)[] | null;
+}
+/** High-level OG renderer — accepts the raw product document from `getProductForDetail`. */
+export declare function renderProductOg(doc: ProductDocLike | null | undefined, opts: OgOptions): ReactElement;
+export declare function renderProductOgImage(data: ProductOgData, siteName: string): ReactElement;
+export {};

package/dist/_internal/server/features/products/og.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** High-level OG renderer — accepts the raw product document from `getProductForDetail`. */
+export function renderProductOg(doc, opts) {
+    return renderProductOgImage({
+        title: doc?.title ?? "Product",
+        price: doc?.price ?? null,
+        imageUrl: doc?.mainImage || doc?.images?.[0] || null,
+    }, opts.siteName);
+}
+export function renderProductOgImage(data, siteName) {
+    const { title, price, imageUrl } = data;
+    const priceLabel = price ? `₹${(price / 100).toLocaleString("en-IN")}` : null;
+    return (_jsxs("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: "#0f172a",
+            fontFamily: "sans-serif",
+            position: "relative",
+            overflow: "hidden",
+        }, children: [imageUrl && (_jsx("img", { src: imageUrl, alt: "", style: { position: "absolute", inset: 0, width: "100%", height: "100%", objectFit: "cover", opacity: 0.15 } })), _jsx("div", { style: {
+                    position: "absolute",
+                    inset: 0,
+                    background: "linear-gradient(135deg, rgba(15,23,42,0.95) 0%, rgba(15,23,42,0.8) 100%)",
+                } }), _jsxs("div", { style: {
+                    position: "relative",
+                    display: "flex",
+                    width: "100%",
+                    height: "100%",
+                    padding: "60px",
+                    gap: "48px",
+                    alignItems: "center",
+                }, children: [imageUrl && (_jsx("img", { src: imageUrl, alt: title, style: { width: 420, height: 420, objectFit: "contain", borderRadius: 16, flexShrink: 0 } })), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 24, flex: 1 }, children: [_jsx("div", { style: { fontSize: 20, color: "#84e122", fontWeight: 600, letterSpacing: 2, textTransform: "uppercase" }, children: siteName }), _jsx("div", { style: {
+                                    fontSize: imageUrl ? 44 : 56,
+                                    fontWeight: 700,
+                                    color: "#f1f5f9",
+                                    lineHeight: 1.2,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 3,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: title }), priceLabel && (_jsx("div", { style: { fontSize: 36, fontWeight: 800, color: "#84e122" }, children: priceLabel }))] })] })] }));
+}

package/dist/_internal/server/features/products/service.d.ts

@@ -0,0 +1,11 @@
+import type { ProductDocument } from "../../../shared/features/products/types";
+/** Assert a product exists and belongs to the given seller. Throws on failure. */
+export declare function assertProductOwnership(productId: string, sellerId: string): Promise<ProductDocument>;
+/** Validate that a status transition is allowed. */
+export declare function assertStatusTransition(from: string, to: string): void;
+/** Assert the product has available stock for a purchase. */
+export declare function assertInStock(product: ProductDocument, quantity?: number): void;
+/** Derive effective price (respects currentBid for auctions, base price otherwise). */
+export declare function effectivePrice(product: ProductDocument): number;
+/** Compute whether a product is still available for purchase. */
+export declare function isAvailableForPurchase(product: ProductDocument): boolean;

package/dist/_internal/server/features/products/service.js

@@ -0,0 +1,55 @@
+import { productRepository } from "../../../../repositories";
+import { isAuctionListing, isPreOrderListing, } from "../../../../features/products/utils/listing-type";
+import { ProductNotFoundError, ProductOwnershipError, ProductStatusError, ProductStockError, } from "../../../shared/features/products/errors";
+const ALLOWED_STATUS_TRANSITIONS = {
+    draft: ["published", "archived"],
+    published: ["archived", "draft"],
+    archived: ["draft"],
+    sold: [],
+    out_of_stock: ["published", "archived"],
+    discontinued: [],
+};
+/** Assert a product exists and belongs to the given seller. Throws on failure. */
+export async function assertProductOwnership(productId, sellerId) {
+    const product = await productRepository.findById(productId).catch(() => null);
+    if (!product)
+        throw new ProductNotFoundError(productId);
+    if (product.storeId !== sellerId)
+        throw new ProductOwnershipError(productId);
+    return product;
+}
+/** Validate that a status transition is allowed. */
+export function assertStatusTransition(from, to) {
+    const allowed = ALLOWED_STATUS_TRANSITIONS[from];
+    if (!allowed || !allowed.includes(to)) {
+        throw new ProductStatusError(from, to);
+    }
+}
+/** Assert the product has available stock for a purchase. */
+export function assertInStock(product, quantity = 1) {
+    if ((product.availableQuantity ?? 0) < quantity) {
+        throw new ProductStockError(`Requested quantity ${quantity} exceeds available stock ${product.availableQuantity ?? 0}`);
+    }
+}
+/** Derive effective price (respects currentBid for auctions, base price otherwise). */
+export function effectivePrice(product) {
+    if (isAuctionListing(product) && product.currentBid)
+        return product.currentBid;
+    return product.price;
+}
+/** Compute whether a product is still available for purchase. */
+export function isAvailableForPurchase(product) {
+    if (product.status !== "published")
+        return false;
+    if (product.isSold)
+        return false;
+    if (isAuctionListing(product)) {
+        const endDate = product.auctionEndDate instanceof Date
+            ? product.auctionEndDate
+            : product.auctionEndDate ? new Date(product.auctionEndDate) : null;
+        return endDate ? endDate.getTime() > Date.now() : false;
+    }
+    if (isPreOrderListing(product))
+        return true;
+    return (product.availableQuantity ?? 0) > 0;
+}

package/dist/_internal/server/features/profile/index.d.ts

@@ -0,0 +1 @@
+export { renderPrivateProfileOgImage, renderUserProfileOgImage, renderProfileOg, type UserProfileOgData } from "./og";

package/dist/_internal/server/features/profile/index.js

@@ -0,0 +1 @@
+export { renderPrivateProfileOgImage, renderUserProfileOgImage, renderProfileOg } from "./og";

package/dist/_internal/server/features/profile/og.d.ts

@@ -0,0 +1,26 @@
+import type { ReactElement } from "react";
+export interface UserProfileOgData {
+    displayName: string;
+    photoURL?: string | null;
+    roleLabel?: string | null;
+}
+export declare function renderPrivateProfileOgImage(siteName: string): ReactElement;
+interface UserDocLike {
+    displayName?: string | null;
+    photoURL?: string | null;
+    role?: string | null;
+    publicProfile?: {
+        isPublic?: boolean | null;
+    } | null;
+}
+/**
+ * High-level OG renderer — accepts the raw user document from `getPublicUserProfile`.
+ * Returns the private-profile fallback when the user is missing or has opted out.
+ */
+export declare function renderProfileOg(doc: UserDocLike | null | undefined, opts: {
+    siteName: string;
+    roleLabels?: Record<string, string>;
+    memberLabel?: string;
+}): ReactElement;
+export declare function renderUserProfileOgImage(data: UserProfileOgData, siteName: string): ReactElement;
+export {};

package/dist/_internal/server/features/profile/og.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function renderPrivateProfileOgImage(siteName) {
+    return (_jsx("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: "#0f172a",
+            fontFamily: "sans-serif",
+            alignItems: "center",
+            justifyContent: "center",
+        }, children: _jsx("div", { style: { fontSize: 48, fontWeight: 700, color: "#f1f5f9" }, children: siteName }) }));
+}
+const ROLE_LABEL = {
+    admin: "Admin",
+    seller: "Seller",
+    buyer: "Buyer",
+    user: "Member",
+};
+/**
+ * High-level OG renderer — accepts the raw user document from `getPublicUserProfile`.
+ * Returns the private-profile fallback when the user is missing or has opted out.
+ */
+export function renderProfileOg(doc, opts) {
+    const isPublic = doc?.publicProfile?.isPublic !== false;
+    if (!doc || !isPublic)
+        return renderPrivateProfileOgImage(opts.siteName);
+    const labels = { ...ROLE_LABEL, ...(opts.roleLabels ?? {}) };
+    const memberLabel = opts.memberLabel ?? "Member";
+    return renderUserProfileOgImage({
+        displayName: doc.displayName ?? `${opts.siteName} ${memberLabel}`,
+        photoURL: doc.photoURL ?? null,
+        roleLabel: labels[doc.role ?? "user"] ?? memberLabel,
+    }, opts.siteName);
+}
+export function renderUserProfileOgImage(data, siteName) {
+    const { displayName, photoURL, roleLabel } = data;
+    return (_jsxs("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: "linear-gradient(135deg, #0f172a 0%, #1e1b4b 100%)",
+            fontFamily: "sans-serif",
+            position: "relative",
+            overflow: "hidden",
+        }, children: [_jsx("div", { style: {
+                    position: "absolute",
+                    top: -100,
+                    left: -100,
+                    width: 500,
+                    height: 500,
+                    borderRadius: "50%",
+                    background: "rgba(20,184,166,0.08)",
+                } }), _jsxs("div", { style: {
+                    position: "relative",
+                    display: "flex",
+                    width: "100%",
+                    height: "100%",
+                    padding: "60px",
+                    gap: "56px",
+                    alignItems: "center",
+                }, children: [_jsx("div", { style: {
+                            width: 220,
+                            height: 220,
+                            borderRadius: "50%",
+                            overflow: "hidden",
+                            flexShrink: 0,
+                            border: "4px solid rgba(20,184,166,0.4)",
+                            background: "rgba(20,184,166,0.08)",
+                            display: "flex",
+                            alignItems: "center",
+                            justifyContent: "center",
+                        }, children: photoURL ? (_jsx("img", { src: photoURL, alt: displayName, style: { width: "100%", height: "100%", objectFit: "cover" } })) : (_jsx("div", { style: { fontSize: 80, color: "#14b8a6" }, children: displayName.charAt(0).toUpperCase() })) }), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 20, flex: 1 }, children: [_jsxs("div", { style: { display: "flex", alignItems: "center", gap: 12 }, children: [_jsxs("div", { style: { fontSize: 16, color: "#14b8a6", fontWeight: 600, letterSpacing: 2, textTransform: "uppercase" }, children: [siteName, " \u00B7 Profile"] }), roleLabel && (_jsx("div", { style: {
+                                            fontSize: 13,
+                                            color: "#5eead4",
+                                            fontWeight: 500,
+                                            letterSpacing: 1,
+                                            textTransform: "uppercase",
+                                            background: "rgba(20,184,166,0.12)",
+                                            padding: "3px 10px",
+                                            borderRadius: 100,
+                                        }, children: roleLabel }))] }), _jsx("div", { style: {
+                                    fontSize: 64,
+                                    fontWeight: 700,
+                                    color: "#f1f5f9",
+                                    lineHeight: 1.1,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 2,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: displayName })] })] })] }));
+}

package/dist/_internal/server/features/promotions/actions.d.ts

@@ -0,0 +1,9 @@
+export declare function applyCouponAction(input: unknown): Promise<{
+    couponId: string;
+    code: string;
+    discount: number;
+    type: import("../../../..").CouponType;
+}>;
+export declare function createCouponAction(input: unknown): Promise<import("../../../..").CouponDocument>;
+export declare function updateCouponAction(couponId: string, input: unknown): Promise<import("../../../..").CouponDocument>;
+export declare function deactivateCouponAction(couponId: string): Promise<import("../../../..").CouponDocument>;