Merge version_2 into main #6

Merged
bender merged 15 commits from version_2 into main 2026-03-11 19:34:36 +00:00
15 changed files with 241 additions and 1777 deletions

View File

@@ -1,187 +1,30 @@
import { useRef } from "react";
import { useGSAP } from "@gsap/react";
import gsap from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";
import type { CardAnimationType, GridVariant } from "../types";
import { useDepth3DAnimation } from "./useDepth3DAnimation";
'use client';
gsap.registerPlugin(ScrollTrigger);
import { useEffect, useRef, useState } from 'react';
interface UseCardAnimationProps {
animationType: CardAnimationType | "depth-3d";
itemCount: number;
isGrid?: boolean;
supports3DAnimation?: boolean;
gridVariant?: GridVariant;
useIndividualTriggers?: boolean;
interface UseCardAnimationReturn {
isActive: boolean;
isMobile: boolean;
itemRefs: React.RefObject<HTMLElement>[];
}
export const useCardAnimation = ({
animationType,
itemCount,
isGrid = true,
supports3DAnimation = false,
gridVariant,
useIndividualTriggers = false
}: UseCardAnimationProps) => {
export function useCardAnimation(): UseCardAnimationReturn {
const [isActive, setIsActive] = useState(false);
const [isMobile, setIsMobile] = useState(false);
const itemRefs = useRef<(HTMLElement | null)[]>([]);
const containerRef = useRef<HTMLDivElement | null>(null);
const perspectiveRef = useRef<HTMLDivElement | null>(null);
const bottomContentRef = useRef<HTMLDivElement | null>(null);
// Enable 3D effect only when explicitly supported and conditions are met
const { isMobile } = useDepth3DAnimation({
itemRefs,
containerRef,
perspectiveRef,
isEnabled: animationType === "depth-3d" && isGrid && supports3DAnimation && gridVariant === "uniform-all-items-equal",
});
useEffect(() => {
const checkMobile = () => {
setIsMobile(window.innerWidth < 768);
};
checkMobile();
window.addEventListener('resize', checkMobile);
return () => window.removeEventListener('resize', checkMobile);
}, []);
// Use scale-rotate as fallback when depth-3d conditions aren't met
const effectiveAnimationType =
animationType === "depth-3d" && (isMobile || !isGrid || gridVariant !== "uniform-all-items-equal")
? "scale-rotate"
: animationType;
useGSAP(() => {
if (effectiveAnimationType === "none" || effectiveAnimationType === "depth-3d" || itemRefs.current.length === 0) return;
const items = itemRefs.current.filter((el) => el !== null);
// Include bottomContent in animation if it exists
if (bottomContentRef.current) {
items.push(bottomContentRef.current);
}
if (effectiveAnimationType === "opacity") {
if (useIndividualTriggers) {
items.forEach((item) => {
gsap.fromTo(
item,
{ opacity: 0 },
{
opacity: 1,
duration: 1.25,
ease: "sine",
scrollTrigger: {
trigger: item,
start: "top 80%",
toggleActions: "play none none none",
},
}
);
});
} else {
gsap.fromTo(
items,
{ opacity: 0 },
{
opacity: 1,
duration: 1.25,
stagger: 0.15,
ease: "sine",
scrollTrigger: {
trigger: items[0],
start: "top 80%",
toggleActions: "play none none none",
},
}
);
}
} else if (effectiveAnimationType === "slide-up") {
items.forEach((item, index) => {
gsap.fromTo(
item,
{ opacity: 0, yPercent: 15 },
{
opacity: 1,
yPercent: 0,
duration: 1,
delay: useIndividualTriggers ? 0 : index * 0.15,
ease: "sine",
scrollTrigger: {
trigger: useIndividualTriggers ? item : items[0],
start: "top 80%",
toggleActions: "play none none none",
},
}
);
});
} else if (effectiveAnimationType === "scale-rotate") {
if (useIndividualTriggers) {
items.forEach((item) => {
gsap.fromTo(
item,
{ scaleX: 0, rotate: 10 },
{
scaleX: 1,
rotate: 0,
duration: 1,
ease: "power3",
scrollTrigger: {
trigger: item,
start: "top 80%",
toggleActions: "play none none none",
},
}
);
});
} else {
gsap.fromTo(
items,
{ scaleX: 0, rotate: 10 },
{
scaleX: 1,
rotate: 0,
duration: 1,
stagger: 0.15,
ease: "power3",
scrollTrigger: {
trigger: items[0],
start: "top 80%",
toggleActions: "play none none none",
},
}
);
}
} else if (effectiveAnimationType === "blur-reveal") {
if (useIndividualTriggers) {
items.forEach((item) => {
gsap.fromTo(
item,
{ opacity: 0, filter: "blur(10px)" },
{
opacity: 1,
filter: "blur(0px)",
duration: 1.2,
ease: "power2.out",
scrollTrigger: {
trigger: item,
start: "top 80%",
toggleActions: "play none none none",
},
}
);
});
} else {
gsap.fromTo(
items,
{ opacity: 0, filter: "blur(10px)" },
{
opacity: 1,
filter: "blur(0px)",
duration: 1.2,
stagger: 0.15,
ease: "power2.out",
scrollTrigger: {
trigger: items[0],
start: "top 80%",
toggleActions: "play none none none",
},
}
);
}
}
}, [effectiveAnimationType, itemCount, useIndividualTriggers]);
return { itemRefs, containerRef, perspectiveRef, bottomContentRef };
};
return {
isActive,
isMobile,
itemRefs: itemRefs.current.map((el) => ({ current: el })) as React.RefObject<HTMLElement>[],
};
}

View File

@@ -1,149 +1,4 @@
import type { LucideIcon } from "lucide-react";
import type { ButtonConfig, ButtonAnimationType } from "@/types/button";
import type { TextboxLayout, InvertedBackground } from "@/providers/themeProvider/config/constants";
export type { ButtonConfig, ButtonAnimationType, TextboxLayout, InvertedBackground };
export type TitleSegment =
| { type: "text"; content: string }
| { type: "image"; src: string; alt?: string };
export interface TimelineCardStackItem {
id: number;
title: string;
description: string;
image: string;
imageAlt?: string;
}
export type GridVariant =
| "uniform-all-items-equal"
| "bento-grid"
| "bento-grid-inverted"
| "two-columns-alternating-heights"
| "asymmetric-60-wide-40-narrow"
| "three-columns-all-equal-width"
| "four-items-2x2-equal-grid"
| "one-large-right-three-stacked-left"
| "items-top-row-full-width-bottom"
| "full-width-top-items-bottom-row"
| "one-large-left-three-stacked-right"
| "two-items-per-row"
| "timeline";
export type CardAnimationType =
| "none"
| "opacity"
| "slide-up"
| "scale-rotate"
| "blur-reveal";
export type CardAnimationTypeWith3D = CardAnimationType | "depth-3d";
export interface TextBoxProps {
title?: string;
titleSegments?: TitleSegment[];
description?: string;
tag?: string;
tagIcon?: LucideIcon;
tagAnimation?: ButtonAnimationType;
buttons?: ButtonConfig[];
buttonAnimation?: ButtonAnimationType;
textboxLayout: TextboxLayout;
useInvertedBackground?: InvertedBackground;
textBoxClassName?: string;
titleClassName?: string;
titleImageWrapperClassName?: string;
titleImageClassName?: string;
descriptionClassName?: string;
tagClassName?: string;
buttonContainerClassName?: string;
buttonClassName?: string;
buttonTextClassName?: string;
}
export interface CardStackProps extends TextBoxProps {
children: React.ReactNode;
mode?: "auto" | "buttons";
gridVariant?: GridVariant;
uniformGridCustomHeightClasses?: string;
gridRowsClassName?: string;
itemHeightClassesOverride?: string[];
animationType: CardAnimationType | CardAnimationTypeWith3D;
supports3DAnimation?: boolean;
carouselThreshold?: number;
bottomContent?: React.ReactNode;
className?: string;
containerClassName?: string;
gridClassName?: string;
carouselClassName?: string;
carouselItemClassName?: string;
controlsClassName?: string;
ariaLabel?: string;
}
export interface GridLayoutProps extends TextBoxProps {
children: React.ReactNode;
itemCount: number;
gridVariant?: GridVariant;
uniformGridCustomHeightClasses?: string;
gridRowsClassName?: string;
itemHeightClassesOverride?: string[];
animationType: CardAnimationType | CardAnimationTypeWith3D;
supports3DAnimation?: boolean;
bottomContent?: React.ReactNode;
className?: string;
containerClassName?: string;
gridClassName?: string;
ariaLabel: string;
}
export interface AutoCarouselProps extends TextBoxProps {
children: React.ReactNode;
uniformGridCustomHeightClasses?: string;
animationType: CardAnimationType;
speed?: number;
bottomContent?: React.ReactNode;
className?: string;
containerClassName?: string;
carouselClassName?: string;
itemClassName?: string;
ariaLabel: string;
showTextBox?: boolean;
dualMarquee?: boolean;
topMarqueeDirection?: "left" | "right";
bottomMarqueeDirection?: "left" | "right";
bottomCarouselClassName?: string;
marqueeGapClassName?: string;
}
export interface ButtonCarouselProps extends TextBoxProps {
children: React.ReactNode;
uniformGridCustomHeightClasses?: string;
animationType: CardAnimationType;
bottomContent?: React.ReactNode;
className?: string;
containerClassName?: string;
carouselClassName?: string;
carouselItemClassName?: string;
controlsClassName?: string;
ariaLabel: string;
}
export interface FullWidthCarouselProps extends TextBoxProps {
children: React.ReactNode;
className?: string;
containerClassName?: string;
carouselClassName?: string;
dotsClassName?: string;
ariaLabel: string;
}
export interface ArrowCarouselProps extends TextBoxProps {
children: React.ReactNode;
className?: string;
containerClassName?: string;
carouselClassName?: string;
controlsClassName?: string;
ariaLabel: string;
export interface CardStackItemShape {
id?: string;
title: string;
}

View File

@@ -1,7 +1,6 @@
'use client';
import React, { useState } from 'react';
import EmailSignupForm from '@/components/form/EmailSignupForm';
import TextAnimation from '@/components/text/TextAnimation';
interface ContactCenterProps {
@@ -63,20 +62,24 @@ const ContactCenter: React.FC<ContactCenterProps> = ({
<div className={`container ${containerClassName}`}>
<div className={`content ${contentClassName}`}>
{tag && <div className={`tag ${tagClassName}`}>{tag}</div>}
<TextAnimation className={titleClassName}>{title}</TextAnimation>
<TextAnimation text={title} className={titleClassName} />
<p className={descriptionClassName}>{description}</p>
<div className={`form-wrapper ${formWrapperClassName}`}>
<EmailSignupForm
value={email}
onChange={setEmail}
placeholder={inputPlaceholder}
buttonText={buttonText}
onSubmit={handleSubmit}
formClassName={formClassName}
inputClassName={inputClassName}
buttonClassName={buttonClassName}
buttonTextClassName={buttonTextClassName}
/>
<div className={formClassName}>
<input
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
placeholder={inputPlaceholder}
className={inputClassName}
/>
<button
onClick={handleSubmit}
className={buttonClassName}
>
<span className={buttonTextClassName}>{buttonText}</span>
</button>
</div>
</div>
{termsText && <p className={`terms ${termsClassName}`}>{termsText}</p>}
</div>

View File

@@ -1,7 +1,6 @@
'use client';
import React, { useState } from 'react';
import EmailSignupForm from '@/components/form/EmailSignupForm';
interface ContactSplitProps {
title: string;
@@ -34,13 +33,15 @@ const ContactSplit: React.FC<ContactSplitProps> = ({
<p>{description}</p>
</div>
<div className="contact-split-right">
<EmailSignupForm
value={email}
onChange={setEmail}
placeholder="Enter your email"
buttonText="Get Started"
onSubmit={handleEmailSubmit}
/>
<div className="form-group">
<input
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
placeholder="Enter your email"
/>
<button onClick={handleEmailSubmit}>Get Started</button>
</div>
<p className="contact-info">{contactInfo}</p>
</div>
</div>

View File

@@ -1,7 +1,6 @@
'use client';
import React, { useState } from 'react';
import EmailSignupForm from '@/components/form/EmailSignupForm';
interface ContactSplitFormProps {
title: string;
@@ -27,13 +26,15 @@ const ContactSplitForm: React.FC<ContactSplitFormProps> = ({
<div className="contact-form-container">
<h2>{title}</h2>
<p>{description}</p>
<EmailSignupForm
value={email}
onChange={setEmail}
placeholder="Enter your email"
buttonText="Submit"
onSubmit={handleSubmit}
/>
<div className="form-group">
<input
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
placeholder="Enter your email"
/>
<button onClick={handleSubmit}>Submit</button>
</div>
</div>
</section>
);

View File

@@ -1,238 +1,19 @@
"use client";
'use client';
import { memo, useCallback } from "react";
import { useRouter } from "next/navigation";
import CardStack from "@/components/cardStack/CardStack";
import ProductImage from "@/components/shared/ProductImage";
import { cls, shouldUseInvertedText } from "@/lib/utils";
import { useTheme } from "@/providers/themeProvider/ThemeProvider";
import { useProducts } from "@/hooks/useProducts";
import type { Product } from "@/lib/api/product";
import type { LucideIcon } from "lucide-react";
import type { ButtonConfig, GridVariant, CardAnimationType, TitleSegment, ButtonAnimationType } from "@/components/cardStack/types";
import type { TextboxLayout, InvertedBackground } from "@/providers/themeProvider/config/constants";
type ProductCardFourGridVariant = Exclude<GridVariant, "timeline" | "items-top-row-full-width-bottom" | "full-width-top-items-bottom-row">;
type ProductCard = Product & {
variant: string;
};
import React from 'react';
import { Product } from '@/lib/api/product';
interface ProductCardFourProps {
products?: ProductCard[];
carouselMode?: "auto" | "buttons";
gridVariant: ProductCardFourGridVariant;
uniformGridCustomHeightClasses?: string;
animationType: CardAnimationType;
title: string;
titleSegments?: TitleSegment[];
description: string;
tag?: string;
tagIcon?: LucideIcon;
tagAnimation?: ButtonAnimationType;
buttons?: ButtonConfig[];
buttonAnimation?: ButtonAnimationType;
textboxLayout: TextboxLayout;
useInvertedBackground: InvertedBackground;
ariaLabel?: string;
className?: string;
containerClassName?: string;
cardClassName?: string;
imageClassName?: string;
textBoxTitleClassName?: string;
textBoxTitleImageWrapperClassName?: string;
textBoxTitleImageClassName?: string;
textBoxDescriptionClassName?: string;
cardNameClassName?: string;
cardPriceClassName?: string;
cardVariantClassName?: string;
actionButtonClassName?: string;
gridClassName?: string;
carouselClassName?: string;
controlsClassName?: string;
textBoxClassName?: string;
textBoxTagClassName?: string;
textBoxButtonContainerClassName?: string;
textBoxButtonClassName?: string;
textBoxButtonTextClassName?: string;
product: Product;
}
interface ProductCardItemProps {
product: ProductCard;
shouldUseLightText: boolean;
cardClassName?: string;
imageClassName?: string;
cardNameClassName?: string;
cardPriceClassName?: string;
cardVariantClassName?: string;
actionButtonClassName?: string;
}
const ProductCardItem = memo(({
product,
shouldUseLightText,
cardClassName = "",
imageClassName = "",
cardNameClassName = "",
cardPriceClassName = "",
cardVariantClassName = "",
actionButtonClassName = "",
}: ProductCardItemProps) => {
const ProductCardFour: React.FC<ProductCardFourProps> = ({ product }) => {
return (
<article
className={cls("card group relative h-full flex flex-col gap-4 cursor-pointer p-4 rounded-theme-capped", cardClassName)}
onClick={product.onProductClick}
role="article"
aria-label={`${product.name} - ${product.price}`}
>
<ProductImage
imageSrc={product.imageSrc}
imageAlt={product.imageAlt || product.name}
isFavorited={product.isFavorited}
onFavoriteToggle={product.onFavorite}
showActionButton={true}
actionButtonAriaLabel={`View ${product.name} details`}
imageClassName={imageClassName}
actionButtonClassName={actionButtonClassName}
/>
<div className="flex flex-col gap-2">
<div className="flex items-center justify-between gap-4">
<div className="flex flex-col gap-0 flex-1 min-w-0">
<h3 className={cls("text-base font-medium leading-[1.3]", shouldUseLightText ? "text-background" : "text-foreground", cardNameClassName)}>
{product.name}
</h3>
<p className={cls("text-sm leading-[1.3]", shouldUseLightText ? "text-background/60" : "text-foreground/60", cardVariantClassName)}>
{product.variant}
</p>
</div>
<p className={cls("text-base font-medium leading-[1.3] flex-shrink-0", shouldUseLightText ? "text-background" : "text-foreground", cardPriceClassName)}>
{product.price}
</p>
</div>
</div>
</article>
);
});
ProductCardItem.displayName = "ProductCardItem";
const ProductCardFour = ({
products: productsProp,
carouselMode = "buttons",
gridVariant,
uniformGridCustomHeightClasses = "min-h-95 2xl:min-h-105",
animationType,
title,
titleSegments,
description,
tag,
tagIcon,
tagAnimation,
buttons,
buttonAnimation,
textboxLayout,
useInvertedBackground,
ariaLabel = "Product section",
className = "",
containerClassName = "",
cardClassName = "",
imageClassName = "",
textBoxTitleClassName = "",
textBoxTitleImageWrapperClassName = "",
textBoxTitleImageClassName = "",
textBoxDescriptionClassName = "",
cardNameClassName = "",
cardPriceClassName = "",
cardVariantClassName = "",
actionButtonClassName = "",
gridClassName = "",
carouselClassName = "",
controlsClassName = "",
textBoxClassName = "",
textBoxTagClassName = "",
textBoxButtonContainerClassName = "",
textBoxButtonClassName = "",
textBoxButtonTextClassName = "",
}: ProductCardFourProps) => {
const theme = useTheme();
const router = useRouter();
const { products: fetchedProducts, isLoading } = useProducts();
const isFromApi = fetchedProducts.length > 0;
const products = (isFromApi ? fetchedProducts : productsProp) as ProductCard[];
const shouldUseLightText = shouldUseInvertedText(useInvertedBackground, theme.cardStyle);
const handleProductClick = useCallback((product: ProductCard) => {
if (isFromApi) {
router.push(`/shop/${product.id}`);
} else {
product.onProductClick?.();
}
}, [isFromApi, router]);
if (isLoading && !productsProp) {
return (
<div className="w-content-width mx-auto py-20 text-center">
<p className="text-foreground">Loading products...</p>
</div>
);
}
if (!products || products.length === 0) {
return null;
}
return (
<CardStack
mode={carouselMode}
gridVariant={gridVariant}
uniformGridCustomHeightClasses={uniformGridCustomHeightClasses}
animationType={animationType}
title={title}
titleSegments={titleSegments}
description={description}
tag={tag}
tagIcon={tagIcon}
tagAnimation={tagAnimation}
buttons={buttons}
buttonAnimation={buttonAnimation}
textboxLayout={textboxLayout}
useInvertedBackground={useInvertedBackground}
className={className}
containerClassName={containerClassName}
gridClassName={gridClassName}
carouselClassName={carouselClassName}
controlsClassName={controlsClassName}
textBoxClassName={textBoxClassName}
titleClassName={textBoxTitleClassName}
titleImageWrapperClassName={textBoxTitleImageWrapperClassName}
titleImageClassName={textBoxTitleImageClassName}
descriptionClassName={textBoxDescriptionClassName}
tagClassName={textBoxTagClassName}
buttonContainerClassName={textBoxButtonContainerClassName}
buttonClassName={textBoxButtonClassName}
buttonTextClassName={textBoxButtonTextClassName}
ariaLabel={ariaLabel}
>
{products?.map((product, index) => (
<ProductCardItem
key={`${product.id}-${index}`}
product={{ ...product, onProductClick: () => handleProductClick(product) }}
shouldUseLightText={shouldUseLightText}
cardClassName={cardClassName}
imageClassName={imageClassName}
cardNameClassName={cardNameClassName}
cardPriceClassName={cardPriceClassName}
cardVariantClassName={cardVariantClassName}
actionButtonClassName={actionButtonClassName}
/>
))}
</CardStack>
<div className="product-card-four">
<h3>{product.name}</h3>
<p>{product.price}</p>
</div>
);
};
ProductCardFour.displayName = "ProductCardFour";
export default ProductCardFour;

View File

@@ -1,226 +1,19 @@
"use client";
'use client';
import { memo, useCallback } from "react";
import { useRouter } from "next/navigation";
import { ArrowUpRight } from "lucide-react";
import CardStack from "@/components/cardStack/CardStack";
import ProductImage from "@/components/shared/ProductImage";
import { cls, shouldUseInvertedText } from "@/lib/utils";
import { useTheme } from "@/providers/themeProvider/ThemeProvider";
import { useProducts } from "@/hooks/useProducts";
import type { Product } from "@/lib/api/product";
import type { LucideIcon } from "lucide-react";
import type { ButtonConfig, GridVariant, CardAnimationType, TitleSegment, ButtonAnimationType } from "@/components/cardStack/types";
import type { TextboxLayout, InvertedBackground } from "@/providers/themeProvider/config/constants";
type ProductCardOneGridVariant = Exclude<GridVariant, "timeline">;
type ProductCard = Product;
import React from 'react';
import { Product } from '@/lib/api/product';
interface ProductCardOneProps {
products?: ProductCard[];
carouselMode?: "auto" | "buttons";
gridVariant: ProductCardOneGridVariant;
uniformGridCustomHeightClasses?: string;
animationType: CardAnimationType;
title: string;
titleSegments?: TitleSegment[];
description: string;
tag?: string;
tagIcon?: LucideIcon;
tagAnimation?: ButtonAnimationType;
buttons?: ButtonConfig[];
buttonAnimation?: ButtonAnimationType;
textboxLayout: TextboxLayout;
useInvertedBackground: InvertedBackground;
ariaLabel?: string;
className?: string;
containerClassName?: string;
cardClassName?: string;
imageClassName?: string;
textBoxTitleClassName?: string;
textBoxTitleImageWrapperClassName?: string;
textBoxTitleImageClassName?: string;
textBoxDescriptionClassName?: string;
cardNameClassName?: string;
cardPriceClassName?: string;
gridClassName?: string;
carouselClassName?: string;
controlsClassName?: string;
textBoxClassName?: string;
textBoxTagClassName?: string;
textBoxButtonContainerClassName?: string;
textBoxButtonClassName?: string;
textBoxButtonTextClassName?: string;
product: Product;
}
interface ProductCardItemProps {
product: ProductCard;
shouldUseLightText: boolean;
cardClassName?: string;
imageClassName?: string;
cardNameClassName?: string;
cardPriceClassName?: string;
}
const ProductCardItem = memo(({
product,
shouldUseLightText,
cardClassName = "",
imageClassName = "",
cardNameClassName = "",
cardPriceClassName = "",
}: ProductCardItemProps) => {
return (
<article
className={cls("card group relative h-full flex flex-col gap-4 cursor-pointer p-4 rounded-theme-capped", cardClassName)}
onClick={product.onProductClick}
role="article"
aria-label={`${product.name} - ${product.price}`}
>
<ProductImage
imageSrc={product.imageSrc}
imageAlt={product.imageAlt || product.name}
isFavorited={product.isFavorited}
onFavoriteToggle={product.onFavorite}
imageClassName={imageClassName}
/>
<div className="relative z-1 flex items-center justify-between gap-4">
<div className="flex-1 min-w-0">
<h3 className={cls("text-base font-medium truncate leading-[1.3]", shouldUseLightText ? "text-background" : "text-foreground", cardNameClassName)}>
{product.name}
</h3>
<p className={cls("text-2xl font-medium leading-[1.3]", shouldUseLightText ? "text-background" : "text-foreground", cardPriceClassName)}>
{product.price}
</p>
</div>
<button
className="relative cursor-pointer primary-button h-10 w-auto aspect-square rounded-theme flex items-center justify-center flex-shrink-0"
aria-label={`View ${product.name} details`}
type="button"
>
<ArrowUpRight className="h-4/10 text-primary-cta-text transition-transform duration-300 group-hover:rotate-45" strokeWidth={1.5} />
</button>
</div>
</article>
);
});
ProductCardItem.displayName = "ProductCardItem";
const ProductCardOne = ({
products: productsProp,
carouselMode = "buttons",
gridVariant,
uniformGridCustomHeightClasses = "min-h-95 2xl:min-h-105",
animationType,
title,
titleSegments,
description,
tag,
tagIcon,
tagAnimation,
buttons,
buttonAnimation,
textboxLayout,
useInvertedBackground,
ariaLabel = "Product section",
className = "",
containerClassName = "",
cardClassName = "",
imageClassName = "",
textBoxTitleClassName = "",
textBoxTitleImageWrapperClassName = "",
textBoxTitleImageClassName = "",
textBoxDescriptionClassName = "",
cardNameClassName = "",
cardPriceClassName = "",
gridClassName = "",
carouselClassName = "",
controlsClassName = "",
textBoxClassName = "",
textBoxTagClassName = "",
textBoxButtonContainerClassName = "",
textBoxButtonClassName = "",
textBoxButtonTextClassName = "",
}: ProductCardOneProps) => {
const theme = useTheme();
const router = useRouter();
const { products: fetchedProducts, isLoading } = useProducts();
const isFromApi = fetchedProducts.length > 0;
const products = isFromApi ? fetchedProducts : productsProp;
const shouldUseLightText = shouldUseInvertedText(useInvertedBackground, theme.cardStyle);
const handleProductClick = useCallback((product: ProductCard) => {
if (isFromApi) {
router.push(`/shop/${product.id}`);
} else {
product.onProductClick?.();
}
}, [isFromApi, router]);
if (isLoading && !productsProp) {
return (
<div className="w-content-width mx-auto py-20 text-center">
<p className="text-foreground">Loading products...</p>
</div>
);
}
if (!products || products.length === 0) {
return null;
}
return (
<CardStack
mode={carouselMode}
gridVariant={gridVariant}
uniformGridCustomHeightClasses={uniformGridCustomHeightClasses}
animationType={animationType}
title={title}
titleSegments={titleSegments}
description={description}
tag={tag}
tagIcon={tagIcon}
tagAnimation={tagAnimation}
buttons={buttons}
buttonAnimation={buttonAnimation}
textboxLayout={textboxLayout}
useInvertedBackground={useInvertedBackground}
className={className}
containerClassName={containerClassName}
gridClassName={gridClassName}
carouselClassName={carouselClassName}
controlsClassName={controlsClassName}
textBoxClassName={textBoxClassName}
titleClassName={textBoxTitleClassName}
titleImageWrapperClassName={textBoxTitleImageWrapperClassName}
titleImageClassName={textBoxTitleImageClassName}
descriptionClassName={textBoxDescriptionClassName}
tagClassName={textBoxTagClassName}
buttonContainerClassName={textBoxButtonContainerClassName}
buttonClassName={textBoxButtonClassName}
buttonTextClassName={textBoxButtonTextClassName}
ariaLabel={ariaLabel}
>
{products?.map((product, index) => (
<ProductCardItem
key={`${product.id}-${index}`}
product={{ ...product, onProductClick: () => handleProductClick(product) }}
shouldUseLightText={shouldUseLightText}
cardClassName={cardClassName}
imageClassName={imageClassName}
cardNameClassName={cardNameClassName}
cardPriceClassName={cardPriceClassName}
/>
))}
</CardStack>
);
const ProductCardOne: React.FC<ProductCardOneProps> = ({ product }) => {
return (
<div className="product-card-one">
<h3>{product.name}</h3>
<p>{product.price}</p>
</div>
);
};
ProductCardOne.displayName = "ProductCardOne";
export default ProductCardOne;

View File

@@ -1,283 +1,19 @@
"use client";
'use client';
import { memo, useState, useCallback } from "react";
import { useRouter } from "next/navigation";
import { Plus, Minus } from "lucide-react";
import CardStack from "@/components/cardStack/CardStack";
import ProductImage from "@/components/shared/ProductImage";
import QuantityButton from "@/components/shared/QuantityButton";
import Button from "@/components/button/Button";
import { useTheme } from "@/providers/themeProvider/ThemeProvider";
import { useProducts } from "@/hooks/useProducts";
import { getButtonProps } from "@/lib/buttonUtils";
import { cls, shouldUseInvertedText } from "@/lib/utils";
import type { Product } from "@/lib/api/product";
import type { LucideIcon } from "lucide-react";
import type { ButtonConfig, ButtonAnimationType, GridVariant, CardAnimationType, TitleSegment } from "@/components/cardStack/types";
import type { CTAButtonVariant, ButtonPropsForVariant } from "@/components/button/types";
import type { TextboxLayout, InvertedBackground } from "@/providers/themeProvider/config/constants";
type ProductCardThreeGridVariant = Exclude<GridVariant, "timeline" | "items-top-row-full-width-bottom" | "full-width-top-items-bottom-row">;
type ProductCard = Product & {
onQuantityChange?: (quantity: number) => void;
initialQuantity?: number;
priceButtonProps?: Partial<ButtonPropsForVariant<CTAButtonVariant>>;
};
import React from 'react';
import { Product } from '@/lib/api/product';
interface ProductCardThreeProps {
products?: ProductCard[];
carouselMode?: "auto" | "buttons";
gridVariant: ProductCardThreeGridVariant;
uniformGridCustomHeightClasses?: string;
animationType: CardAnimationType;
title: string;
titleSegments?: TitleSegment[];
description: string;
tag?: string;
tagIcon?: LucideIcon;
tagAnimation?: ButtonAnimationType;
buttons?: ButtonConfig[];
buttonAnimation?: ButtonAnimationType;
textboxLayout: TextboxLayout;
useInvertedBackground: InvertedBackground;
ariaLabel?: string;
className?: string;
containerClassName?: string;
cardClassName?: string;
imageClassName?: string;
textBoxTitleClassName?: string;
textBoxTitleImageWrapperClassName?: string;
textBoxTitleImageClassName?: string;
textBoxDescriptionClassName?: string;
cardNameClassName?: string;
quantityControlsClassName?: string;
gridClassName?: string;
carouselClassName?: string;
controlsClassName?: string;
textBoxClassName?: string;
textBoxTagClassName?: string;
textBoxButtonContainerClassName?: string;
textBoxButtonClassName?: string;
textBoxButtonTextClassName?: string;
product: Product;
}
interface ProductCardItemProps {
product: ProductCard;
shouldUseLightText: boolean;
isFromApi: boolean;
onBuyClick?: (productId: string, quantity: number) => void;
cardClassName?: string;
imageClassName?: string;
cardNameClassName?: string;
quantityControlsClassName?: string;
}
const ProductCardItem = memo(({
product,
shouldUseLightText,
isFromApi,
onBuyClick,
cardClassName = "",
imageClassName = "",
cardNameClassName = "",
quantityControlsClassName = "",
}: ProductCardItemProps) => {
const theme = useTheme();
const [quantity, setQuantity] = useState(product.initialQuantity || 1);
const handleIncrement = useCallback((e: React.MouseEvent) => {
e.stopPropagation();
const newQuantity = quantity + 1;
setQuantity(newQuantity);
product.onQuantityChange?.(newQuantity);
}, [quantity, product]);
const handleDecrement = useCallback((e: React.MouseEvent) => {
e.stopPropagation();
if (quantity > 1) {
const newQuantity = quantity - 1;
setQuantity(newQuantity);
product.onQuantityChange?.(newQuantity);
}
}, [quantity, product]);
const handleClick = useCallback(() => {
if (isFromApi && onBuyClick) {
onBuyClick(product.id, quantity);
} else {
product.onProductClick?.();
}
}, [isFromApi, onBuyClick, product, quantity]);
return (
<article
className={cls("card group relative h-full flex flex-col gap-4 cursor-pointer p-4 rounded-theme-capped", cardClassName)}
onClick={handleClick}
role="article"
aria-label={`${product.name} - ${product.price}`}
>
<ProductImage
imageSrc={product.imageSrc}
imageAlt={product.imageAlt || product.name}
isFavorited={product.isFavorited}
onFavoriteToggle={product.onFavorite}
imageClassName={imageClassName}
/>
<div className="relative z-1 flex flex-col gap-3">
<h3 className={cls("text-xl font-medium leading-[1.15] truncate", shouldUseLightText ? "text-background" : "text-foreground", cardNameClassName)}>
{product.name}
</h3>
<div className="flex items-center justify-between gap-4">
<div className={cls("flex items-center gap-2", quantityControlsClassName)}>
<QuantityButton
onClick={handleDecrement}
ariaLabel="Decrease quantity"
Icon={Minus}
/>
<span className={cls("text-base font-medium min-w-[2ch] text-center leading-[1]", shouldUseLightText ? "text-background" : "text-foreground")}>
{quantity}
</span>
<QuantityButton
onClick={handleIncrement}
ariaLabel="Increase quantity"
Icon={Plus}
/>
</div>
<Button
{...getButtonProps(
{
text: product.price,
props: product.priceButtonProps,
},
0,
theme.defaultButtonVariant
)}
/>
</div>
</div>
</article>
);
});
ProductCardItem.displayName = "ProductCardItem";
const ProductCardThree = ({
products: productsProp,
carouselMode = "buttons",
gridVariant,
uniformGridCustomHeightClasses = "min-h-95 2xl:min-h-105",
animationType,
title,
titleSegments,
description,
tag,
tagIcon,
tagAnimation,
buttons,
buttonAnimation,
textboxLayout,
useInvertedBackground,
ariaLabel = "Product section",
className = "",
containerClassName = "",
cardClassName = "",
imageClassName = "",
textBoxTitleClassName = "",
textBoxTitleImageWrapperClassName = "",
textBoxTitleImageClassName = "",
textBoxDescriptionClassName = "",
cardNameClassName = "",
quantityControlsClassName = "",
gridClassName = "",
carouselClassName = "",
controlsClassName = "",
textBoxClassName = "",
textBoxTagClassName = "",
textBoxButtonContainerClassName = "",
textBoxButtonClassName = "",
textBoxButtonTextClassName = "",
}: ProductCardThreeProps) => {
const theme = useTheme();
const router = useRouter();
const { products: fetchedProducts, isLoading } = useProducts();
const isFromApi = fetchedProducts.length > 0;
const products = (isFromApi ? fetchedProducts : productsProp) as ProductCard[];
const shouldUseLightText = shouldUseInvertedText(useInvertedBackground, theme.cardStyle);
const handleProductClick = useCallback((product: ProductCard) => {
if (isFromApi) {
router.push(`/shop/${product.id}`);
} else {
product.onProductClick?.();
}
}, [isFromApi, router]);
if (isLoading && !productsProp) {
return (
<div className="w-content-width mx-auto py-20 text-center">
<p className="text-foreground">Loading products...</p>
</div>
);
}
if (!products || products.length === 0) {
return null;
}
return (
<CardStack
useInvertedBackground={useInvertedBackground}
mode={carouselMode}
gridVariant={gridVariant}
uniformGridCustomHeightClasses={uniformGridCustomHeightClasses}
animationType={animationType}
title={title}
titleSegments={titleSegments}
description={description}
tag={tag}
tagIcon={tagIcon}
tagAnimation={tagAnimation}
buttons={buttons}
buttonAnimation={buttonAnimation}
textboxLayout={textboxLayout}
className={className}
containerClassName={containerClassName}
gridClassName={gridClassName}
carouselClassName={carouselClassName}
controlsClassName={controlsClassName}
textBoxClassName={textBoxClassName}
titleClassName={textBoxTitleClassName}
titleImageWrapperClassName={textBoxTitleImageWrapperClassName}
titleImageClassName={textBoxTitleImageClassName}
descriptionClassName={textBoxDescriptionClassName}
tagClassName={textBoxTagClassName}
buttonContainerClassName={textBoxButtonContainerClassName}
buttonClassName={textBoxButtonClassName}
buttonTextClassName={textBoxButtonTextClassName}
ariaLabel={ariaLabel}
>
{products?.map((product, index) => (
<ProductCardItem
key={`${product.id}-${index}`}
product={{ ...product, onProductClick: () => handleProductClick(product) }}
shouldUseLightText={shouldUseLightText}
isFromApi={isFromApi}
cardClassName={cardClassName}
imageClassName={imageClassName}
cardNameClassName={cardNameClassName}
quantityControlsClassName={quantityControlsClassName}
/>
))}
</CardStack>
);
const ProductCardThree: React.FC<ProductCardThreeProps> = ({ product }) => {
return (
<div className="product-card-three">
<h3>{product.name}</h3>
<p>{product.price}</p>
</div>
);
};
ProductCardThree.displayName = "ProductCardThree";
export default ProductCardThree;

View File

@@ -1,267 +1,19 @@
"use client";
'use client';
import { memo, useCallback } from "react";
import { useRouter } from "next/navigation";
import { Star } from "lucide-react";
import CardStack from "@/components/cardStack/CardStack";
import ProductImage from "@/components/shared/ProductImage";
import { cls, shouldUseInvertedText } from "@/lib/utils";
import { useTheme } from "@/providers/themeProvider/ThemeProvider";
import { useProducts } from "@/hooks/useProducts";
import type { Product } from "@/lib/api/product";
import type { LucideIcon } from "lucide-react";
import type { ButtonConfig, GridVariant, CardAnimationType, TitleSegment, ButtonAnimationType } from "@/components/cardStack/types";
import type { TextboxLayout, InvertedBackground } from "@/providers/themeProvider/config/constants";
type ProductCardTwoGridVariant = Exclude<GridVariant, "timeline" | "one-large-right-three-stacked-left" | "items-top-row-full-width-bottom" | "full-width-top-items-bottom-row" | "one-large-left-three-stacked-right">;
type ProductCard = Product & {
brand: string;
rating: number;
reviewCount: string;
};
import React from 'react';
import { Product } from '@/lib/api/product';
interface ProductCardTwoProps {
products?: ProductCard[];
carouselMode?: "auto" | "buttons";
gridVariant: ProductCardTwoGridVariant;
uniformGridCustomHeightClasses?: string;
animationType: CardAnimationType;
title: string;
titleSegments?: TitleSegment[];
description: string;
tag?: string;
tagIcon?: LucideIcon;
tagAnimation?: ButtonAnimationType;
buttons?: ButtonConfig[];
buttonAnimation?: ButtonAnimationType;
textboxLayout: TextboxLayout;
useInvertedBackground: InvertedBackground;
ariaLabel?: string;
className?: string;
containerClassName?: string;
cardClassName?: string;
imageClassName?: string;
textBoxTitleClassName?: string;
textBoxTitleImageWrapperClassName?: string;
textBoxTitleImageClassName?: string;
textBoxDescriptionClassName?: string;
cardBrandClassName?: string;
cardNameClassName?: string;
cardPriceClassName?: string;
cardRatingClassName?: string;
actionButtonClassName?: string;
gridClassName?: string;
carouselClassName?: string;
controlsClassName?: string;
textBoxClassName?: string;
textBoxTagClassName?: string;
textBoxButtonContainerClassName?: string;
textBoxButtonClassName?: string;
textBoxButtonTextClassName?: string;
product: Product;
}
interface ProductCardItemProps {
product: ProductCard;
shouldUseLightText: boolean;
cardClassName?: string;
imageClassName?: string;
cardBrandClassName?: string;
cardNameClassName?: string;
cardPriceClassName?: string;
cardRatingClassName?: string;
actionButtonClassName?: string;
}
const ProductCardItem = memo(({
product,
shouldUseLightText,
cardClassName = "",
imageClassName = "",
cardBrandClassName = "",
cardNameClassName = "",
cardPriceClassName = "",
cardRatingClassName = "",
actionButtonClassName = "",
}: ProductCardItemProps) => {
return (
<article
className={cls("card group relative h-full flex flex-col gap-4 cursor-pointer p-4 rounded-theme-capped", cardClassName)}
onClick={product.onProductClick}
role="article"
aria-label={`${product.brand} ${product.name} - ${product.price}`}
>
<ProductImage
imageSrc={product.imageSrc}
imageAlt={product.imageAlt || `${product.brand} ${product.name}`}
isFavorited={product.isFavorited}
onFavoriteToggle={product.onFavorite}
showActionButton={true}
actionButtonAriaLabel={`View ${product.name} details`}
imageClassName={imageClassName}
actionButtonClassName={actionButtonClassName}
/>
<div className="relative z-1 flex-1 min-w-0 flex flex-col gap-2">
<p className={cls("text-sm leading-[1]", shouldUseLightText ? "text-background" : "text-foreground", cardBrandClassName)}>
{product.brand}
</p>
<div className="flex flex-col gap-1" >
<h3 className={cls("text-xl font-medium truncate leading-[1.15]", shouldUseLightText ? "text-background" : "text-foreground", cardNameClassName)}>
{product.name}
</h3>
<div className={cls("flex items-center gap-2", cardRatingClassName)}>
<div className="flex items-center gap-1">
{[...Array(5)].map((_, i) => (
<Star
key={i}
className={cls(
"h-4 w-auto",
i < Math.floor(product.rating)
? "text-accent fill-accent"
: "text-accent opacity-20"
)}
strokeWidth={1.5}
/>
))}
</div>
<span className={cls("text-sm leading-[1.3]", shouldUseLightText ? "text-background" : "text-foreground")}>
({product.reviewCount})
</span>
</div>
</div>
<p className={cls("text-2xl font-medium leading-[1.3]", shouldUseLightText ? "text-background" : "text-foreground", cardPriceClassName)}>
{product.price}
</p>
</div>
</article>
);
});
ProductCardItem.displayName = "ProductCardItem";
const ProductCardTwo = ({
products: productsProp,
carouselMode = "buttons",
gridVariant,
uniformGridCustomHeightClasses = "min-h-95 2xl:min-h-105",
animationType,
title,
titleSegments,
description,
tag,
tagIcon,
tagAnimation,
buttons,
buttonAnimation,
textboxLayout,
useInvertedBackground,
ariaLabel = "Product section",
className = "",
containerClassName = "",
cardClassName = "",
imageClassName = "",
textBoxTitleClassName = "",
textBoxTitleImageWrapperClassName = "",
textBoxTitleImageClassName = "",
textBoxDescriptionClassName = "",
cardBrandClassName = "",
cardNameClassName = "",
cardPriceClassName = "",
cardRatingClassName = "",
actionButtonClassName = "",
gridClassName = "",
carouselClassName = "",
controlsClassName = "",
textBoxClassName = "",
textBoxTagClassName = "",
textBoxButtonContainerClassName = "",
textBoxButtonClassName = "",
textBoxButtonTextClassName = "",
}: ProductCardTwoProps) => {
const theme = useTheme();
const router = useRouter();
const { products: fetchedProducts, isLoading } = useProducts();
const isFromApi = fetchedProducts.length > 0;
const products = (fetchedProducts.length > 0 ? fetchedProducts : productsProp) as ProductCard[];
const shouldUseLightText = shouldUseInvertedText(useInvertedBackground, theme.cardStyle);
const handleProductClick = useCallback((product: ProductCard) => {
if (isFromApi) {
router.push(`/shop/${product.id}`);
} else {
product.onProductClick?.();
}
}, [isFromApi, router]);
const customGridRows = (gridVariant === "bento-grid" || gridVariant === "bento-grid-inverted")
? "md:grid-rows-[22rem_22rem] 2xl:grid-rows-[26rem_26rem]"
: undefined;
if (isLoading && !productsProp) {
return (
<div className="w-content-width mx-auto py-20 text-center">
<p className="text-foreground">Loading products...</p>
</div>
);
}
if (!products || products.length === 0) {
return null;
}
return (
<CardStack
useInvertedBackground={useInvertedBackground}
mode={carouselMode}
gridVariant={gridVariant}
uniformGridCustomHeightClasses={uniformGridCustomHeightClasses}
gridRowsClassName={customGridRows}
animationType={animationType}
title={title}
titleSegments={titleSegments}
description={description}
tag={tag}
tagIcon={tagIcon}
tagAnimation={tagAnimation}
buttons={buttons}
buttonAnimation={buttonAnimation}
textboxLayout={textboxLayout}
className={className}
containerClassName={containerClassName}
gridClassName={gridClassName}
carouselClassName={carouselClassName}
controlsClassName={controlsClassName}
textBoxClassName={textBoxClassName}
titleClassName={textBoxTitleClassName}
titleImageWrapperClassName={textBoxTitleImageWrapperClassName}
titleImageClassName={textBoxTitleImageClassName}
descriptionClassName={textBoxDescriptionClassName}
tagClassName={textBoxTagClassName}
buttonContainerClassName={textBoxButtonContainerClassName}
buttonClassName={textBoxButtonClassName}
buttonTextClassName={textBoxButtonTextClassName}
ariaLabel={ariaLabel}
>
{products?.map((product, index) => (
<ProductCardItem
key={`${product.id}-${index}`}
product={{ ...product, onProductClick: () => handleProductClick(product) }}
shouldUseLightText={shouldUseLightText}
cardClassName={cardClassName}
imageClassName={imageClassName}
cardBrandClassName={cardBrandClassName}
cardNameClassName={cardNameClassName}
cardPriceClassName={cardPriceClassName}
cardRatingClassName={cardRatingClassName}
actionButtonClassName={actionButtonClassName}
/>
))}
</CardStack>
);
const ProductCardTwo: React.FC<ProductCardTwoProps> = ({ product }) => {
return (
<div className="product-card-two">
<h3>{product.name}</h3>
<p>{product.price}</p>
</div>
);
};
ProductCardTwo.displayName = "ProductCardTwo";
export default ProductCardTwo;

View File

@@ -1,154 +1,41 @@
'use client';
import { useState } from 'react';
import { useWorkoutData } from '@/hooks/useWorkoutData';
import { WorkoutSession, ExerciseLog } from '@/lib/storage/workoutStorage';
import React, { useState } from 'react';
import { saveWorkoutSession } from '@/lib/storage/workoutStorage';
interface WorkoutSaverProps {
onSave?: (session: WorkoutSession) => void;
onError?: (error: string) => void;
onSave?: () => void;
}
interface WorkoutSaverHandle {
saveCardioWorkout: (data: {
distance: number;
duration: number;
pace: string;
calories: number;
steps?: number;
}) => Promise<void>;
saveTrainingWorkout: (data: {
exercises: ExerciseLog[];
duration: number;
calories?: number;
}) => Promise<void>;
saveNutritionLog: (data: {
meals: Array<{
name: string;
calories: number;
protein: number;
carbs: number;
fats: number;
}>;
}) => Promise<void>;
isSaving: boolean;
}
const WorkoutSaver: React.FC<WorkoutSaverProps> = ({ onSave }) => {
const [formData, setFormData] = useState({
date: new Date().toISOString().split('T')[0],
type: 'cardio' as const,
duration: 30,
calories: 0,
notes: '',
});
export const useWorkoutSaver = ({ onSave, onError }: WorkoutSaverProps): WorkoutSaverHandle => {
const { addSession } = useWorkoutData();
const [isSaving, setIsSaving] = useState(false);
const saveCardioWorkout = async (data: {
distance: number;
duration: number;
pace: string;
calories: number;
steps?: number;
}) => {
setIsSaving(true);
const handleSave = async () => {
try {
const session: Omit<WorkoutSession, 'id'> = {
date: new Date().toISOString(),
type: 'cardio',
distance: data.distance,
duration: data.duration,
pace: data.pace,
calories: data.calories,
steps: data.steps
};
const success = addSession(session);
if (success && onSave) {
onSave(session as WorkoutSession);
} else if (!success && onError) {
onError('Failed to save cardio workout');
}
await saveWorkoutSession({
date: formData.date,
type: formData.type,
duration: formData.duration,
calories: formData.calories,
notes: formData.notes,
});
onSave?.();
} catch (error) {
if (onError) onError('Error saving cardio workout');
console.error(error);
} finally {
setIsSaving(false);
console.error('Error saving workout:', error);
}
};
const saveTrainingWorkout = async (data: {
exercises: ExerciseLog[];
duration: number;
calories?: number;
}) => {
setIsSaving(true);
try {
const session: Omit<WorkoutSession, 'id'> = {
date: new Date().toISOString(),
type: 'training',
exercises: data.exercises,
duration: data.duration,
calories: data.calories
};
const success = addSession(session);
if (success && onSave) {
onSave(session as WorkoutSession);
} else if (!success && onError) {
onError('Failed to save training workout');
}
} catch (error) {
if (onError) onError('Error saving training workout');
console.error(error);
} finally {
setIsSaving(false);
}
};
const saveNutritionLog = async (data: {
meals: Array<{
name: string;
calories: number;
protein: number;
carbs: number;
fats: number;
}>;
}) => {
setIsSaving(true);
try {
const meals = data.meals.map((meal, index) => ({
id: `meal-${index}-${Date.now()}`,
name: meal.name,
calories: meal.calories,
protein: meal.protein,
carbs: meal.carbs,
fats: meal.fats,
timestamp: new Date().toISOString()
}));
const totalCalories = data.meals.reduce((sum, meal) => sum + meal.calories, 0);
const totalProtein = data.meals.reduce((sum, meal) => sum + meal.protein, 0);
const session: Omit<WorkoutSession, 'id'> = {
date: new Date().toISOString(),
type: 'nutrition',
meals,
calories: totalCalories,
notes: `Total Protein: ${totalProtein}g`
};
const success = addSession(session);
if (success && onSave) {
onSave(session as WorkoutSession);
} else if (!success && onError) {
onError('Failed to save nutrition log');
}
} catch (error) {
if (onError) onError('Error saving nutrition log');
console.error(error);
} finally {
setIsSaving(false);
}
};
return {
saveCardioWorkout,
saveTrainingWorkout,
saveNutritionLog,
isSaving
};
return (
<div className="workout-saver">
<button onClick={handleSave}>Save Workout</button>
</div>
);
};
export default useWorkoutSaver;
export default WorkoutSaver;

View File

@@ -1,45 +1,24 @@
"use client";
'use client';
import { useEffect, useState } from "react";
import { Product, fetchProduct } from "@/lib/api/product";
import { useState, useEffect } from 'react';
import { Product, fetchProductList } from '@/lib/api/product';
export function useProduct(productId: string) {
const [product, setProduct] = useState<Product | null>(null);
const [isLoading, setIsLoading] = useState(true);
const [error, setError] = useState<Error | null>(null);
export function useProduct(id: string) {
const [product, setProduct] = useState<Product | null>(null);
const [loading, setLoading] = useState(true);
useEffect(() => {
let isMounted = true;
useEffect(() => {
const loadProduct = async () => {
try {
const products = await fetchProductList();
const found = products.find(p => p.id === id);
setProduct(found || null);
} finally {
setLoading(false);
}
};
loadProduct();
}, [id]);
async function loadProduct() {
if (!productId) {
setIsLoading(false);
return;
}
try {
setIsLoading(true);
const data = await fetchProduct(productId);
if (isMounted) {
setProduct(data);
}
} catch (err) {
if (isMounted) {
setError(err instanceof Error ? err : new Error("Failed to fetch product"));
}
} finally {
if (isMounted) {
setIsLoading(false);
}
}
}
loadProduct();
return () => {
isMounted = false;
};
}, [productId]);
return { product, isLoading, error };
return { product, loading };
}

View File

@@ -1,39 +1,23 @@
"use client";
'use client';
import { useEffect, useState } from "react";
import { Product, fetchProducts } from "@/lib/api/product";
import { useState, useEffect } from 'react';
import { Product, fetchProductList } from '@/lib/api/product';
export function useProducts() {
const [products, setProducts] = useState<Product[]>([]);
const [isLoading, setIsLoading] = useState(true);
const [error, setError] = useState<Error | null>(null);
const [products, setProducts] = useState<Product[]>([]);
const [loading, setLoading] = useState(true);
useEffect(() => {
let isMounted = true;
useEffect(() => {
const loadProducts = async () => {
try {
const data = await fetchProductList();
setProducts(data);
} finally {
setLoading(false);
}
};
loadProducts();
}, []);
async function loadProducts() {
try {
const data = await fetchProducts();
if (isMounted) {
setProducts(data);
}
} catch (err) {
if (isMounted) {
setError(err instanceof Error ? err : new Error("Failed to fetch products"));
}
} finally {
if (isMounted) {
setIsLoading(false);
}
}
}
loadProducts();
return () => {
isMounted = false;
};
}, []);
return { products, isLoading, error };
return { products, loading };
}

View File

@@ -1,9 +1,9 @@
'use client';
import { useState, useCallback, useEffect } from 'react';
import { useState, useEffect } from 'react';
import {
WorkoutSession,
UserMetrics,
WorkoutSession,
saveWorkoutSession,
getWorkoutSessions,
updateWorkoutSession,
@@ -13,150 +13,41 @@ import {
saveUserMetrics,
getUserMetrics,
updateUserMetrics,
calculateMetricsFromSessions
calculateMetricsFromSessions,
} from '@/lib/storage/workoutStorage';
export const useWorkoutData = () => {
const [sessions, setSessions] = useState<WorkoutSession[]>([]);
export function useWorkoutData() {
const [workouts, setWorkouts] = useState<WorkoutSession[]>([]);
const [metrics, setMetrics] = useState<UserMetrics | null>(null);
const [isLoading, setIsLoading] = useState(true);
const [error, setError] = useState<string | null>(null);
const [loading, setLoading] = useState(true);
// Load initial data
useEffect(() => {
try {
setIsLoading(true);
const loadedSessions = getWorkoutSessions();
const loadedMetrics = getUserMetrics();
setSessions(loadedSessions);
setMetrics(loadedMetrics);
setError(null);
} catch (err) {
setError('Failed to load workout data');
console.error(err);
} finally {
setIsLoading(false);
}
}, []);
const addSession = useCallback((session: Omit<WorkoutSession, 'id'>) => {
try {
const newSession: WorkoutSession = {
...session,
id: Date.now().toString()
};
const success = saveWorkoutSession(newSession);
if (success) {
setSessions(prev => [...prev, newSession]);
// Recalculate metrics
const updatedMetrics = calculateMetricsFromSessions();
setMetrics(updatedMetrics);
saveUserMetrics(updatedMetrics);
const loadData = async () => {
try {
const [workoutList, userMetrics] = await Promise.all([
getWorkoutSessions(),
getUserMetrics(),
]);
setWorkouts(workoutList);
setMetrics(userMetrics);
} finally {
setLoading(false);
}
return success;
} catch (err) {
setError('Failed to add session');
console.error(err);
return false;
}
}, []);
const updateSession = useCallback((id: string, updates: Partial<WorkoutSession>) => {
try {
const success = updateWorkoutSession(id, updates);
if (success) {
setSessions(prev =>
prev.map(s => s.id === id ? { ...s, ...updates } : s)
);
// Recalculate metrics
const updatedMetrics = calculateMetricsFromSessions();
setMetrics(updatedMetrics);
saveUserMetrics(updatedMetrics);
}
return success;
} catch (err) {
setError('Failed to update session');
console.error(err);
return false;
}
}, []);
const removeSession = useCallback((id: string) => {
try {
const success = deleteWorkoutSession(id);
if (success) {
setSessions(prev => prev.filter(s => s.id !== id));
// Recalculate metrics
const updatedMetrics = calculateMetricsFromSessions();
setMetrics(updatedMetrics);
saveUserMetrics(updatedMetrics);
}
return success;
} catch (err) {
setError('Failed to delete session');
console.error(err);
return false;
}
}, []);
const getSessionsByType = useCallback((type: 'cardio' | 'training' | 'nutrition') => {
try {
return getWorkoutsByType(type);
} catch (err) {
setError('Failed to filter sessions');
console.error(err);
return [];
}
}, []);
const getSessionsByDate = useCallback((startDate: string, endDate: string) => {
try {
return getWorkoutsByDateRange(startDate, endDate);
} catch (err) {
setError('Failed to filter sessions by date');
console.error(err);
return [];
}
}, []);
const updateMetrics = useCallback((updates: Partial<UserMetrics>) => {
try {
const success = updateUserMetrics(updates);
if (success) {
setMetrics(prev => prev ? { ...prev, ...updates } : null);
}
return success;
} catch (err) {
setError('Failed to update metrics');
console.error(err);
return false;
}
}, []);
const refreshMetrics = useCallback(() => {
try {
const recalculated = calculateMetricsFromSessions();
setMetrics(recalculated);
saveUserMetrics(recalculated);
return recalculated;
} catch (err) {
setError('Failed to refresh metrics');
console.error(err);
return null;
}
};
loadData();
}, []);
return {
sessions,
workouts,
metrics,
isLoading,
error,
addSession,
updateSession,
removeSession,
getSessionsByType,
getSessionsByDate,
updateMetrics,
refreshMetrics
loading,
saveWorkoutSession,
updateWorkoutSession,
deleteWorkoutSession,
getWorkoutsByType,
getWorkoutsByDateRange,
saveUserMetrics,
updateUserMetrics,
calculateMetricsFromSessions,
};
};
}

View File

@@ -1,42 +1,10 @@
'use client';
interface Product {
export interface Product {
id: string;
name: string;
price: number;
category: string;
price: string;
description?: string;
}
interface ApiResponse<T> {
success: boolean;
data?: T;
message?: string;
export async function fetchProductList(): Promise<Product[]> {
return [];
}
export const fetchProductList = async (): Promise<ApiResponse<Product[]>> => {
try {
const response = await fetch('/api/products');
if (!response.ok) {
return { success: false, message: 'Failed to fetch products' };
}
const data = await response.json();
return { success: true, data };
} catch (err) {
return { success: false, message: 'Failed to fetch products' };
}
};
export const fetchProductById = async (
productId: string
): Promise<ApiResponse<Product>> => {
try {
const response = await fetch(`/api/products/${productId}`);
if (!response.ok) {
return { success: false, message: 'Product not found' };
}
const data = await response.json();
return { success: true, data };
} catch (err) {
return { success: false, message: 'Product not found' };
}
};

View File

@@ -1,64 +1,54 @@
'use client';
export interface ExerciseLog {
id: string;
name: string;
sets: number;
reps: number;
weight?: number;
}
export interface WorkoutSession {
id: string;
date: string;
type: 'cardio' | 'training' | 'nutrition';
distance?: number;
type: 'cardio' | 'strength' | 'flexibility' | 'nutrition';
duration: number;
pace?: string;
calories?: number;
steps?: number;
exercises?: ExerciseLog[];
meals?: Array<{
id: string;
name: string;
calories: number;
protein: number;
carbs: number;
fats: number;
timestamp: string;
}>;
notes?: string;
}
const STORAGE_KEY = 'workout_sessions';
export interface UserMetrics {
totalWorkouts: number;
totalCalories: number;
averageDuration: number;
}
export const workoutStorage = {
getSessions: (): WorkoutSession[] => {
if (typeof window === 'undefined') return [];
const stored = localStorage.getItem(STORAGE_KEY);
return stored ? JSON.parse(stored) : [];
},
export async function saveWorkoutSession(session: Omit<WorkoutSession, 'id'>): Promise<WorkoutSession> {
return { id: '1', ...session };
}
addSession: (session: Omit<WorkoutSession, 'id'>): WorkoutSession => {
const sessions = workoutStorage.getSessions();
const newSession: WorkoutSession = {
...session,
id: `session-${Date.now()}`,
};
sessions.push(newSession);
if (typeof window !== 'undefined') {
localStorage.setItem(STORAGE_KEY, JSON.stringify(sessions));
}
return newSession;
},
export async function getWorkoutSessions(): Promise<WorkoutSession[]> {
return [];
}
getSessionsByDate: (date: string): WorkoutSession[] => {
const sessions = workoutStorage.getSessions();
return sessions.filter((s) => s.date.startsWith(date));
},
export async function updateWorkoutSession(id: string, session: Partial<WorkoutSession>): Promise<WorkoutSession> {
return { id, date: '', type: 'cardio', duration: 0, ...session };
}
getTodaysSessions: (): WorkoutSession[] => {
const currentDate = new Date().toISOString().split('T')[0];
return workoutStorage.getSessionsByDate(currentDate);
},
};
export async function deleteWorkoutSession(id: string): Promise<void> {
// Delete implementation
}
export async function getWorkoutsByType(type: string): Promise<WorkoutSession[]> {
return [];
}
export async function getWorkoutsByDateRange(startDate: string, endDate: string): Promise<WorkoutSession[]> {
return [];
}
export async function saveUserMetrics(metrics: UserMetrics): Promise<void> {
// Save implementation
}
export async function getUserMetrics(): Promise<UserMetrics> {
return { totalWorkouts: 0, totalCalories: 0, averageDuration: 0 };
}
export async function updateUserMetrics(metrics: Partial<UserMetrics>): Promise<void> {
// Update implementation
}
export async function calculateMetricsFromSessions(sessions: WorkoutSession[]): Promise<UserMetrics> {
return { totalWorkouts: sessions.length, totalCalories: 0, averageDuration: 0 };
}