@mohasinac/appkit 2.1.3 → 2.2.0

package/dist/features/auth/schemas/index.js

@@ -0,0 +1,41 @@
+export * from "./firestore";
+import { z } from "zod";
+// ─── Form schemas ─────────────────────────────────────────────────────────────
+/**
+ * Login form schema — use with react-hook-form + zodResolver.
+ *
+ * @example
+ * import { loginSchema } from "@mohasinac/feat-auth";
+ * const form = useForm({ resolver: zodResolver(loginSchema) });
+ */
+export const loginSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(6),
+});
+export const registerSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(6),
+    displayName: z.string().min(1).optional(),
+});
+export const forgotPasswordSchema = z.object({
+    email: z.string().email(),
+});
+export const resetPasswordSchema = z.object({
+    token: z.string().min(1),
+    password: z.string().min(6),
+});
+// ─── Auth user schema ─────────────────────────────────────────────────────────
+export const userRoleSchema = z.enum([
+    "customer",
+    "seller",
+    "admin",
+    "superadmin",
+]);
+export const authUserSchema = z.object({
+    id: z.string(),
+    email: z.string().email().optional(),
+    displayName: z.string().optional(),
+    photoURL: z.string().optional(),
+    role: userRoleSchema.optional(),
+    isEmailVerified: z.boolean().optional(),
+});

package/dist/features/auth/server.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @mohasinac/appkit/features/auth/server
+ *
+ * Server-only entry point — exports only the API route handlers.
+ * Import this sub-path from Next.js API routes to avoid bundling
+ * client-side React components into server bundles.
+ *
+ * @example
+ * ```ts
+ * // app/api/auth/me/route.ts
+ * import { withProviders } from "@/providers.config";
+ * import { authMeGET } from "@mohasinac/appkit/features/auth/server";
+ * export const GET = withProviders(authMeGET);
+ * ```
+ */
+import "server-only";
+export * from "./token-store";
+export * from "./consent-otp";
+export * from "./repository";
+export * from "./actions";
+export { authMeGET } from "./api/route";

package/dist/features/auth/server.js

@@ -0,0 +1,21 @@
+/**
+ * @mohasinac/appkit/features/auth/server
+ *
+ * Server-only entry point — exports only the API route handlers.
+ * Import this sub-path from Next.js API routes to avoid bundling
+ * client-side React components into server bundles.
+ *
+ * @example
+ * ```ts
+ * // app/api/auth/me/route.ts
+ * import { withProviders } from "@/providers.config";
+ * import { authMeGET } from "@mohasinac/appkit/features/auth/server";
+ * export const GET = withProviders(authMeGET);
+ * ```
+ */
+import "server-only";
+export * from "./token-store";
+export * from "./consent-otp";
+export * from "./repository";
+export * from "./actions";
+export { authMeGET } from "./api/route";

package/dist/features/auth/token-helpers.d.ts

@@ -0,0 +1,7 @@
+export declare function generateVerificationToken(): string;
+export declare function generateVerificationCode(): string;
+export declare function calculateTokenExpiration(hoursFromNow?: number): Date;
+export declare function isTokenExpired(expiresAt: Date | string): boolean;
+export declare function getTokenTimeRemaining(expiresAt: Date | string): number;
+export declare function maskToken(token: string): string;
+export declare function generateSessionId(): string;

package/dist/features/auth/token-helpers.js

@@ -0,0 +1,37 @@
+function getCryptoApi() {
+    if (!globalThis.crypto) {
+        throw new Error("Crypto API is not available in this runtime");
+    }
+    return globalThis.crypto;
+}
+export function generateVerificationToken() {
+    return getCryptoApi().randomUUID();
+}
+export function generateVerificationCode() {
+    const array = new Uint32Array(1);
+    getCryptoApi().getRandomValues(array);
+    return ((array[0] % 900000) + 100000).toString();
+}
+export function calculateTokenExpiration(hoursFromNow = 24) {
+    const expiration = new Date();
+    expiration.setHours(expiration.getHours() + hoursFromNow);
+    return expiration;
+}
+export function isTokenExpired(expiresAt) {
+    const expiry = typeof expiresAt === "string" ? new Date(expiresAt) : expiresAt;
+    return expiry.getTime() < Date.now();
+}
+export function getTokenTimeRemaining(expiresAt) {
+    const expiry = typeof expiresAt === "string" ? new Date(expiresAt) : expiresAt;
+    const remaining = expiry.getTime() - Date.now();
+    return Math.max(0, Math.floor(remaining / 60000));
+}
+export function maskToken(token) {
+    if (token.length <= 8) {
+        return token;
+    }
+    return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+export function generateSessionId() {
+    return generateVerificationToken();
+}

package/dist/features/auth/token-store.d.ts

@@ -0,0 +1,39 @@
+import "server-only";
+import { EMAIL_VERIFICATION_COLLECTION, PASSWORD_RESET_COLLECTION } from "./schemas";
+export interface TokenData {
+    userId: string;
+    email: string;
+    token: string;
+    expiresAt: Date;
+    createdAt: Date;
+}
+export interface PasswordResetTokenData extends TokenData {
+    used: boolean;
+    usedAt?: Date;
+}
+export interface TokenServiceConfig {
+    emailVerificationExpiryMs?: number;
+    passwordResetExpiryMs?: number;
+}
+export interface TokenErrorMessages {
+    emailTokenInvalid?: string;
+    emailTokenExpired?: string;
+    passwordTokenInvalid?: string;
+    passwordTokenExpired?: string;
+    passwordTokenUsed?: string;
+}
+export declare function generateToken(length?: number): string;
+export declare function createVerificationToken(userId: string, email: string, config?: TokenServiceConfig): Promise<string>;
+export declare function createPasswordResetToken(userId: string, email: string, config?: TokenServiceConfig): Promise<string>;
+export declare function verifyEmailToken(token: string, errors?: TokenErrorMessages): Promise<{
+    valid: boolean;
+    userId?: string;
+    error?: string;
+}>;
+export declare function verifyPasswordResetToken(token: string, errors?: TokenErrorMessages): Promise<{
+    valid: boolean;
+    userId?: string;
+    error?: string;
+}>;
+export declare function markPasswordResetTokenAsUsed(token: string): Promise<void>;
+export declare function deleteToken(collection: typeof EMAIL_VERIFICATION_COLLECTION | typeof PASSWORD_RESET_COLLECTION, token: string): Promise<void>;

package/dist/features/auth/token-store.js

@@ -0,0 +1,120 @@
+import "server-only";
+import crypto from "crypto";
+import { getAdminDb, prepareForFirestore } from "../../providers/db-firebase";
+import { resolveDate } from "../../utils";
+import { EMAIL_VERIFICATION_COLLECTION, PASSWORD_RESET_COLLECTION, } from "./schemas";
+const DEFAULT_TOKEN_CONFIG = {
+    emailVerificationExpiryMs: 24 * 60 * 60 * 1000,
+    passwordResetExpiryMs: 60 * 60 * 1000,
+};
+const DEFAULT_TOKEN_ERRORS = {
+    emailTokenInvalid: "Invalid verification token",
+    emailTokenExpired: "Verification token has expired",
+    passwordTokenInvalid: "Invalid password reset token",
+    passwordTokenExpired: "Password reset token has expired",
+    passwordTokenUsed: "Password reset token has already been used",
+};
+export function generateToken(length = 32) {
+    return crypto.randomBytes(length).toString("hex");
+}
+export async function createVerificationToken(userId, email, config) {
+    const token = generateToken();
+    const mergedConfig = { ...DEFAULT_TOKEN_CONFIG, ...config };
+    const expiresAt = new Date(Date.now() + mergedConfig.emailVerificationExpiryMs);
+    const tokenData = prepareForFirestore({
+        userId,
+        email,
+        token,
+        expiresAt,
+        createdAt: new Date(),
+    });
+    await getAdminDb()
+        .collection(EMAIL_VERIFICATION_COLLECTION)
+        .doc(token)
+        .set(tokenData);
+    return token;
+}
+export async function createPasswordResetToken(userId, email, config) {
+    const token = generateToken();
+    const mergedConfig = { ...DEFAULT_TOKEN_CONFIG, ...config };
+    const expiresAt = new Date(Date.now() + mergedConfig.passwordResetExpiryMs);
+    const tokenData = prepareForFirestore({
+        userId,
+        email,
+        token,
+        expiresAt,
+        createdAt: new Date(),
+        used: false,
+    });
+    await getAdminDb()
+        .collection(PASSWORD_RESET_COLLECTION)
+        .doc(token)
+        .set(tokenData);
+    return token;
+}
+export async function verifyEmailToken(token, errors) {
+    const mergedErrors = { ...DEFAULT_TOKEN_ERRORS, ...errors };
+    const tokenDoc = await getAdminDb()
+        .collection(EMAIL_VERIFICATION_COLLECTION)
+        .doc(token)
+        .get();
+    if (!tokenDoc.exists) {
+        return { valid: false, error: mergedErrors.emailTokenInvalid };
+    }
+    const tokenData = tokenDoc.data();
+    if (!tokenData) {
+        return { valid: false, error: mergedErrors.emailTokenInvalid };
+    }
+    const expiresAt = resolveDate(tokenData.expiresAt);
+    if (!expiresAt || expiresAt < new Date()) {
+        await getAdminDb()
+            .collection(EMAIL_VERIFICATION_COLLECTION)
+            .doc(token)
+            .delete();
+        return { valid: false, error: mergedErrors.emailTokenExpired };
+    }
+    await getAdminDb()
+        .collection(EMAIL_VERIFICATION_COLLECTION)
+        .doc(token)
+        .delete();
+    return { valid: true, userId: tokenData.userId };
+}
+export async function verifyPasswordResetToken(token, errors) {
+    const mergedErrors = { ...DEFAULT_TOKEN_ERRORS, ...errors };
+    const tokenDoc = await getAdminDb()
+        .collection(PASSWORD_RESET_COLLECTION)
+        .doc(token)
+        .get();
+    if (!tokenDoc.exists) {
+        return { valid: false, error: mergedErrors.passwordTokenInvalid };
+    }
+    const tokenData = tokenDoc.data();
+    if (!tokenData) {
+        return { valid: false, error: mergedErrors.passwordTokenInvalid };
+    }
+    const expiresAt = resolveDate(tokenData.expiresAt);
+    if (!expiresAt || expiresAt < new Date()) {
+        await getAdminDb()
+            .collection(PASSWORD_RESET_COLLECTION)
+            .doc(token)
+            .delete();
+        return { valid: false, error: mergedErrors.passwordTokenExpired };
+    }
+    if (tokenData.used) {
+        return { valid: false, error: mergedErrors.passwordTokenUsed };
+    }
+    return { valid: true, userId: tokenData.userId };
+}
+export async function markPasswordResetTokenAsUsed(token) {
+    const updateData = prepareForFirestore({
+        used: true,
+        usedAt: new Date(),
+    });
+    await getAdminDb()
+        .collection(PASSWORD_RESET_COLLECTION)
+        .doc(token)
+        .update(updateData);
+}
+export async function deleteToken(collection, token) {
+    await getAdminDb().collection(collection).doc(token).delete();
+}

package/dist/features/auth/types/index.d.ts

@@ -0,0 +1,30 @@
+export type UserRole = "user" | "seller" | "moderator" | "admin";
+export interface AuthUser {
+    id: string;
+    email?: string;
+    displayName?: string;
+    photoURL?: string;
+    role?: UserRole;
+    isEmailVerified?: boolean;
+}
+export interface LoginInput {
+    email: string;
+    password: string;
+}
+export interface RegisterInput {
+    email: string;
+    password: string;
+    displayName?: string;
+}
+export interface ForgotPasswordInput {
+    email: string;
+}
+export interface ResetPasswordInput {
+    token: string;
+    password: string;
+}
+export interface AuthState {
+    user: AuthUser | null;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+}

package/dist/features/auth/types/index.js

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

package/dist/features/before-after/api/[id]/route.d.ts

@@ -0,0 +1,26 @@
+/**
+ * feat-before-after — GET/PATCH/DELETE /api/before-after/[id]
+ *
+ * Before/After content retrieval, updates, and deletion.
+ *
+ * Consumer stub:
+ * ```ts
+ * export { beforeAfterDetailGET as GET, beforeAfterDetailPATCH as PATCH, beforeAfterDetailDELETE as DELETE } from "@mohasinac/feat-before-after";
+ * ```
+ */
+import { NextResponse } from "next/server.js";
+export declare function GET(request: Request, { params }: {
+    params: {
+        id: string;
+    };
+}): Promise<NextResponse>;
+export declare function PATCH(request: Request, { params }: {
+    params: {
+        id: string;
+    };
+}): Promise<NextResponse>;
+export declare function DELETE(request: Request, { params }: {
+    params: {
+        id: string;
+    };
+}): Promise<NextResponse>;

package/dist/features/before-after/api/[id]/route.js

@@ -0,0 +1,88 @@
+/**
+ * feat-before-after — GET/PATCH/DELETE /api/before-after/[id]
+ *
+ * Before/After content retrieval, updates, and deletion.
+ *
+ * Consumer stub:
+ * ```ts
+ * export { beforeAfterDetailGET as GET, beforeAfterDetailPATCH as PATCH, beforeAfterDetailDELETE as DELETE } from "@mohasinac/feat-before-after";
+ * ```
+ */
+import { NextResponse } from "next/server.js";
+import { getProviders } from "../../../../contracts";
+export async function GET(request, { params }) {
+    try {
+        const { id } = await params;
+        if (!id) {
+            return NextResponse.json({ success: false, error: "ID required" }, { status: 400 });
+        }
+        const { db } = getProviders();
+        if (!db)
+            return NextResponse.json({ success: false, error: "DB not configured" }, { status: 503 });
+        const repo = db.getRepository("before_after");
+        const item = await repo.findById(id);
+        if (!item) {
+            return NextResponse.json({ success: false, error: "Item not found" }, { status: 404 });
+        }
+        return NextResponse.json({
+            success: true,
+            data: item,
+        });
+    }
+    catch (error) {
+        return NextResponse.json({
+            success: false,
+            error: error instanceof Error ? error.message : "Internal server error",
+        }, { status: 500 });
+    }
+}
+export async function PATCH(request, { params }) {
+    try {
+        const { id } = await params;
+        if (!id) {
+            return NextResponse.json({ success: false, error: "ID required" }, { status: 400 });
+        }
+        const body = await request.json();
+        const { db } = getProviders();
+        if (!db)
+            return NextResponse.json({ success: false, error: "DB not configured" }, { status: 503 });
+        const repo = db.getRepository("before_after");
+        const updated = await repo.update(id, body);
+        if (!updated) {
+            return NextResponse.json({ success: false, error: "Item not found" }, { status: 404 });
+        }
+        return NextResponse.json({
+            success: true,
+            data: updated,
+        });
+    }
+    catch (error) {
+        return NextResponse.json({
+            success: false,
+            error: error instanceof Error ? error.message : "Internal server error",
+        }, { status: 500 });
+    }
+}
+export async function DELETE(request, { params }) {
+    try {
+        const { id } = await params;
+        if (!id) {
+            return NextResponse.json({ success: false, error: "ID required" }, { status: 400 });
+        }
+        const { db } = getProviders();
+        if (!db)
+            return NextResponse.json({ success: false, error: "DB not configured" }, { status: 503 });
+        const repo = db.getRepository("before_after");
+        await repo.delete(id);
+        return NextResponse.json({
+            success: true,
+            data: { id },
+        });
+    }
+    catch (error) {
+        return NextResponse.json({
+            success: false,
+            error: error instanceof Error ? error.message : "Internal server error",
+        }, { status: 500 });
+    }
+}

package/dist/features/before-after/api/route.d.ts

@@ -0,0 +1,13 @@
+/**
+ * feat-before-after — GET/POST /api/before-after
+ *
+ * Before/After content list with Sieve filtering and creation.
+ *
+ * Consumer stub:
+ * ```ts
+ * export { beforeAfterListGET as GET, beforeAfterListPOST as POST } from "@mohasinac/feat-before-after";
+ * ```
+ */
+import { NextResponse } from "next/server.js";
+export declare function GET(request: Request): Promise<NextResponse>;
+export declare function POST(request: Request): Promise<NextResponse>;

package/dist/features/before-after/api/route.js

@@ -0,0 +1,79 @@
+/**
+ * feat-before-after — GET/POST /api/before-after
+ *
+ * Before/After content list with Sieve filtering and creation.
+ *
+ * Consumer stub:
+ * ```ts
+ * export { beforeAfterListGET as GET, beforeAfterListPOST as POST } from "@mohasinac/feat-before-after";
+ * ```
+ */
+import { NextResponse } from "next/server.js";
+import { getProviders } from "../../../contracts";
+function numParam(url, key, fallback) {
+    const v = url.searchParams.get(key);
+    const n = v !== null ? Number(v) : NaN;
+    return Number.isFinite(n) ? n : fallback;
+}
+export async function GET(request) {
+    try {
+        const url = new URL(request.url);
+        const page = Math.max(1, numParam(url, "page", 1));
+        const pageSize = Math.min(100, Math.max(1, numParam(url, "pageSize", 20)));
+        const filters = url.searchParams.get("filters") ?? undefined;
+        const sort = url.searchParams.get("sorts") ??
+            url.searchParams.get("sort") ??
+            "-createdAt";
+        const { db } = getProviders();
+        if (!db)
+            return NextResponse.json({ success: false, error: "DB not configured" }, { status: 503 });
+        const repo = db.getRepository("before_after");
+        const result = await repo.findAll({
+            filters,
+            sort,
+            page,
+            perPage: pageSize,
+        });
+        const totalPages = Math.max(1, Math.ceil(result.total / pageSize));
+        return NextResponse.json({
+            success: true,
+            data: {
+                items: result.data,
+                total: result.total,
+                page,
+                pageSize,
+                totalPages,
+                hasMore: page < totalPages,
+            },
+        });
+    }
+    catch (error) {
+        return NextResponse.json({
+            success: false,
+            error: error instanceof Error ? error.message : "Internal server error",
+        }, { status: 500 });
+    }
+}
+export async function POST(request) {
+    try {
+        const body = await request.json();
+        const { db } = getProviders();
+        if (!db)
+            return NextResponse.json({ success: false, error: "DB not configured" }, { status: 503 });
+        const repo = db.getRepository("before_after");
+        const created = await repo.create({
+            ...body,
+            createdAt: new Date(),
+        });
+        return NextResponse.json({
+            success: true,
+            data: created,
+        }, { status: 201 });
+    }
+    catch (error) {
+        return NextResponse.json({
+            success: false,
+            error: error instanceof Error ? error.message : "Internal server error",
+        }, { status: 500 });
+    }
+}

package/dist/features/before-after/columns/index.d.ts

@@ -0,0 +1,17 @@
+import type { TableColumn, ColumnExtensionOpts } from "../../../contracts";
+import type { BeforeAfterItem } from "../types";
+/**
+ * Default admin columns for before-after items.
+ * Use `buildBeforeAfterColumns()` to customise via overrides / extras / omit.
+ */
+export declare const beforeAfterAdminColumns: TableColumn<BeforeAfterItem>[];
+/**
+ * Factory that returns columns for the before-after admin table.
+ *
+ * @example
+ * const cols = buildBeforeAfterColumns<MyBeforeAfterItem>({
+ *   extras: [{ key: "doctorName", header: "Doctor", render: (b) => b.doctorName }],
+ *   omit: ["sortOrder"],
+ * });
+ */
+export declare function buildBeforeAfterColumns<T extends BeforeAfterItem = BeforeAfterItem>(opts?: ColumnExtensionOpts<T>): TableColumn<T>[];

package/dist/features/before-after/columns/index.js

@@ -0,0 +1,50 @@
+import { buildColumns, renderBoolean } from "../../../ui/columns";
+/**
+ * Default admin columns for before-after items.
+ * Use `buildBeforeAfterColumns()` to customise via overrides / extras / omit.
+ */
+export const beforeAfterAdminColumns = [
+    {
+        key: "title",
+        header: "Title",
+        sortable: true,
+    },
+    {
+        key: "concern",
+        header: "Concern",
+        sortable: false,
+    },
+    {
+        key: "durationWeeks",
+        header: "Duration (wks)",
+        sortable: true,
+    },
+    {
+        key: "isActive",
+        header: "Active",
+        sortable: false,
+        render: (item) => renderBoolean(item.isActive),
+    },
+    {
+        key: "sortOrder",
+        header: "Order",
+        sortable: true,
+    },
+    {
+        key: "createdAt",
+        header: "Created",
+        sortable: true,
+    },
+];
+/**
+ * Factory that returns columns for the before-after admin table.
+ *
+ * @example
+ * const cols = buildBeforeAfterColumns<MyBeforeAfterItem>({
+ *   extras: [{ key: "doctorName", header: "Doctor", render: (b) => b.doctorName }],
+ *   omit: ["sortOrder"],
+ * });
+ */
+export function buildBeforeAfterColumns(opts) {
+    return buildColumns(beforeAfterAdminColumns, opts);
+}

package/dist/features/before-after/components/BeforeAfterGallery.d.ts

@@ -0,0 +1,7 @@
+import type { BeforeAfterItem } from "../types";
+interface BeforeAfterGalleryProps {
+    items: BeforeAfterItem[];
+    className?: string;
+}
+export declare function BeforeAfterGallery({ items, className, }: BeforeAfterGalleryProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/before-after/components/BeforeAfterGallery.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { BeforeAfterSlider } from "./BeforeAfterSlider";
+import { Div, Text } from "../../../ui";
+export function BeforeAfterGallery({ items, className = "", }) {
+    if (items.length === 0)
+        return null;
+    return (_jsx(Div, { className: `grid grid-cols-1 gap-6 sm:grid-cols-2 lg:grid-cols-3 ${className}`, children: items.map((item) => (_jsxs(Div, { className: "flex flex-col gap-2", children: [_jsx(BeforeAfterSlider, { item: item }), (item.title || item.description) && (_jsxs(Div, { className: "text-center", children: [item.title && (_jsx(Text, { className: "text-sm font-semibold text-neutral-900", children: item.title })), item.description && (_jsx(Text, { className: "mt-0.5 text-xs text-neutral-500", children: item.description }))] }))] }, item.id))) }));
+}

package/dist/features/before-after/components/BeforeAfterSlider.d.ts

@@ -0,0 +1,7 @@
+import type { BeforeAfterItem } from "../types";
+interface BeforeAfterSliderProps {
+    item: BeforeAfterItem;
+    className?: string;
+}
+export declare function BeforeAfterSlider({ item, className, }: BeforeAfterSliderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/before-after/components/BeforeAfterSlider.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+import { Div, Span } from "../../../ui";
+export function BeforeAfterSlider({ item, className = "", }) {
+    const [position, setPosition] = useState(50);
+    const containerRef = useRef(null);
+    function handlePointerMove(e) {
+        if (!(e.buttons & 1))
+            return;
+        move(e.clientX);
+    }
+    function handleTouchMove(e) {
+        move(e.touches[0].clientX);
+    }
+    function move(clientX) {
+        const rect = containerRef.current?.getBoundingClientRect();
+        if (!rect)
+            return;
+        const x = Math.max(0, Math.min(clientX - rect.left, rect.width));
+        setPosition((x / rect.width) * 100);
+    }
+    return (_jsxs(Div, { ref: containerRef, className: `relative aspect-square select-none overflow-hidden rounded-xl ${className}`, onPointerMove: handlePointerMove, onTouchMove: handleTouchMove, children: [_jsx(Div, { role: "img", "aria-label": "After", className: "absolute inset-0 h-full w-full bg-center bg-cover", style: { backgroundImage: `url(${item.afterImageUrl})` } }), _jsx(Div, { className: "absolute inset-0 overflow-hidden", style: { width: `${position}%` }, children: _jsx(Div, { role: "img", "aria-label": "Before", className: "h-full w-full bg-center bg-cover", style: {
+                        width: containerRef.current?.offsetWidth ?? "100%",
+                        backgroundImage: `url(${item.beforeImageUrl})`,
+                    } }) }), _jsxs(Div, { className: "absolute inset-y-0 flex w-1 -translate-x-1/2 cursor-ew-resize flex-col items-center justify-center", style: { left: `${position}%` }, children: [_jsx(Div, { className: "h-full w-0.5 bg-white/80 shadow" }), _jsx(Div, { className: "absolute h-8 w-8 rounded-full border-2 border-white bg-white/80 shadow-md" })] }), _jsx(Span, { className: "absolute left-2 top-2 rounded bg-black/40 px-2 py-0.5 text-xs font-medium text-white", children: "Before" }), _jsx(Span, { className: "absolute right-2 top-2 rounded bg-black/40 px-2 py-0.5 text-xs font-medium text-white", children: "After" }), item.durationWeeks && (_jsxs(Span, { className: "absolute bottom-2 left-1/2 -translate-x-1/2 rounded bg-black/50 px-3 py-1 text-xs font-medium text-white", children: [item.durationWeeks, " weeks"] }))] }));
+}

package/dist/features/before-after/components/index.d.ts

@@ -0,0 +1,2 @@
+export { BeforeAfterSlider } from "./BeforeAfterSlider";
+export { BeforeAfterGallery } from "./BeforeAfterGallery";

package/dist/features/before-after/components/index.js

@@ -0,0 +1,2 @@
+export { BeforeAfterSlider } from "./BeforeAfterSlider";
+export { BeforeAfterGallery } from "./BeforeAfterGallery";