@tapcart/mobile-components 0.2.4 → 0.2.8

package/dist/components/ui/tabs.js

@@ -0,0 +1,96 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import { cva } from "class-variance-authority";
+import { cn } from "../../lib/utils";
+import { Text } from "./text";
+const tabVariants = cva("flex items-center justify-center px-4 py-2 w-full", {
+    variants: {
+        isActive: {
+            true: "[&>p]:text-textColors-primaryColor",
+            false: "[&>p]:text-textColors-secondaryColor",
+        },
+    },
+    defaultVariants: {
+        isActive: false,
+    },
+});
+const Tab = ({ label, isActive = false, onClick }) => {
+    return (_jsx("button", Object.assign({ className: cn(tabVariants({
+            isActive,
+        })), onClick: onClick }, { children: _jsx(Text, Object.assign({ type: "body-primary" }, { children: label }), void 0) }), void 0));
+};
+const Tabs = React.forwardRef((_a, ref) => {
+    var { className, tabs, activeTab, onTabChange } = _a, props = __rest(_a, ["className", "tabs", "activeTab", "onTabChange"]);
+    const [underlinePosition, setUnderlinePosition] = React.useState({
+        left: 0,
+        width: 0,
+    });
+    const containerRef = React.useRef(null);
+    const [showLeftGradient, setShowLeftGradient] = React.useState(false);
+    const [showRightGradient, setShowRightGradient] = React.useState(false);
+    React.useEffect(() => {
+        onTabChange(activeTab);
+    }, [activeTab, tabs, onTabChange]);
+    const checkShowGradients = () => {
+        const { scrollLeft, scrollWidth, clientWidth } = containerRef.current;
+        setShowLeftGradient(scrollLeft > 0);
+        setShowRightGradient(scrollLeft + clientWidth < scrollWidth);
+    };
+    const handleTabChanged = React.useCallback(() => {
+        var _a, _b;
+        const currentTab = containerRef.current.children[activeTab];
+        setUnderlinePosition({
+            left: (_a = currentTab === null || currentTab === void 0 ? void 0 : currentTab.offsetLeft) !== null && _a !== void 0 ? _a : 0,
+            width: (_b = currentTab === null || currentTab === void 0 ? void 0 : currentTab.clientWidth) !== null && _b !== void 0 ? _b : 0,
+        });
+        currentTab.scrollIntoView({
+            behavior: "smooth",
+            block: "nearest",
+            inline: "center",
+        });
+    }, [activeTab]);
+    React.useEffect(() => {
+        handleTabChanged();
+        window.addEventListener("resize", handleTabChanged);
+        return () => {
+            window.removeEventListener("resize", handleTabChanged);
+        };
+    }, [handleTabChanged]);
+    React.useEffect(() => {
+        const handleResize = () => checkShowGradients();
+        window.addEventListener("resize", handleResize);
+        checkShowGradients();
+        return () => window.removeEventListener("resize", handleResize);
+    }, []);
+    React.useEffect(() => {
+        checkShowGradients();
+    }, [tabs]);
+    React.useEffect(() => {
+        if (ref) {
+            if (typeof ref === "function") {
+                ref(containerRef.current);
+            }
+            else {
+                ref.current = containerRef.current;
+            }
+        }
+    }, [ref]);
+    return (_jsxs("div", Object.assign({ className: "relative" }, props, { children: [_jsxs("div", Object.assign({ ref: containerRef, className: "relative flex overflow-x-auto", onScroll: checkShowGradients }, { children: [tabs.map((tab, index) => (_jsx(Tab, { label: tab.label, isActive: activeTab === index, onClick: () => onTabChange(index) }, index))), _jsx("div", { className: `absolute bottom-0 bg-coreColors-brandColorPrimary h-[2px] transition-all duration-300`, style: {
+                            left: underlinePosition.left,
+                            width: underlinePosition.width,
+                        } }, void 0)] }), void 0), showRightGradient ? (_jsx("div", { className: "absolute right-0 bottom-0 w-16 h-10 bg-[linear-gradient(90deg,#ffffff00_0%,#FFF_100%)] pointer-events-none" }, void 0)) : (_jsx(_Fragment, {}, void 0)), showLeftGradient ? (_jsx("div", { className: "absolute left-0 bottom-0 w-16 h-10 bg-[linear-gradient(270deg,#ffffff00_0%,#FFF_100%)] pointer-events-none" }, void 0)) : (_jsx(_Fragment, {}, void 0))] }), void 0));
+});
+Tabs.displayName = "Tabs";
+export { Tabs };

package/dist/components/ui/text.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const textVariants: (props?: ({
+    type?: "h1" | "h2" | "label" | "body-primary" | "body-secondary" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface TextProps extends React.HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof textVariants> {
+}
+declare function Text({ className, type, ...props }: TextProps): import("react/jsx-runtime").JSX.Element;
+export { Text, textVariants };
+//# sourceMappingURL=text.d.ts.map

package/dist/components/ui/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../components/ui/text.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAGjE,QAAA,MAAM,YAAY;;mFAgBhB,CAAA;AAEF,MAAM,WAAW,SACf,SAAQ,KAAK,CAAC,cAAc,CAAC,oBAAoB,CAAC,EAChD,YAAY,CAAC,OAAO,YAAY,CAAC;CAAG;AAExC,iBAAS,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,SAAS,2CAErD;AAED,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,CAAA"}

package/dist/components/ui/text.js

@@ -0,0 +1,33 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { cn } from "../../lib/utils";
+const textVariants = cva("", {
+    variants: {
+        type: {
+            h1: "text-[23px] font-sfpro-roboto leading-[130%] font-normal text-textColors-primaryColor",
+            h2: "text-lg font-sfpro-roboto leading-[130%] font-medium text-textColors-primaryColor",
+            "body-primary": "text-[15px] font-sfpro-roboto leading-[160%] font-normal text-textColors-primaryColor",
+            "body-secondary": "text-[12px] font-sfpro-roboto leading-[130%] font-normal text-textColors-secondaryColor",
+            label: "text-[10px] font-sfpro-roboto leading-[130%] font-normal text-textColors-secondaryColor",
+        },
+    },
+    defaultVariants: {
+        type: "body-primary",
+    },
+});
+function Text(_a) {
+    var { className, type } = _a, props = __rest(_a, ["className", "type"]);
+    return _jsx("p", Object.assign({ className: cn(textVariants({ type }), className) }, props), void 0);
+}
+export { Text, textVariants };

package/dist/components/ui/toast.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { type VariantProps } from "class-variance-authority";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "error" | "warning" | "success" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare type ToastType = "default" | "warning" | "error" | "success";
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    type?: "default" | "error" | "warning" | "success" | undefined;
+    icon?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+declare type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, type ToastType, };
+//# sourceMappingURL=toast.d.ts.map

package/dist/components/ui/toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast.d.ts","sourceRoot":"","sources":["../../../components/ui/toast.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,eAAe,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAOjE,QAAA,MAAM,aAAa,8CAA2B,CAAA;AAE9C,QAAA,MAAM,aAAa,kKAYjB,CAAA;AAgCF,QAAA,MAAM,KAAK;;0HAYT,CAAA;AAGF,QAAA,MAAM,WAAW,kKAYf,CAAA;AAGF,QAAA,MAAM,UAAU,iKAed,CAAA;AAGF,QAAA,MAAM,UAAU,2JASd,CAAA;AAEF,aAAK,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;AAiC5D,QAAA,MAAM,gBAAgB;;;wCAiBpB,CAAA;AAGF,aAAK,UAAU,GAAG,KAAK,CAAC,wBAAwB,CAAC,OAAO,KAAK,CAAC,CAAA;AAE9D,aAAK,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAAC,OAAO,WAAW,CAAC,CAAA;AAEhE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,aAAa,EACb,aAAa,EACb,KAAK,EACL,UAAU,EACV,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,KAAK,SAAS,GACf,CAAA"}

package/dist/components/ui/toast.js

@@ -0,0 +1,98 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { cva } from "class-variance-authority";
+import { X } from "lucide-react";
+import { cn } from "../../lib/utils";
+import { Icon } from "./icon";
+import { Text } from "./text";
+const ToastProvider = ToastPrimitives.Provider;
+const ToastViewport = React.forwardRef((_a, ref) => {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(ToastPrimitives.Viewport, Object.assign({ ref: ref, className: cn("fixed z-[100] top-0 flex max-h-screen w-full flex-col items-center right-0", className) }, props), void 0));
+});
+ToastViewport.displayName = ToastPrimitives.Viewport.displayName;
+const toastVariants = cva(`fixed w-full pb-4 pt-12 px-4 h-auto group pointer-events-auto flex items-center justify-between shadow-[0_0_6px_0_rgba(17,17,17,0.16)] transition-all
+  data-[swipe=cancel]:translate-x-0 
+        data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] 
+        data-[swipe=end]:animate-out 
+        data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] 
+        data-[swipe=move]:transition-none 
+        data-[state=closed]:animate-out 
+        data-[state=closed]:fade-out-0 
+        data-[state=closed]:slide-out-to-top-full 
+        data-[state=open]:slide-in-from-top-full
+        data-[state=open]:animate-in
+        data-[state=open]:duration-500`, {
+    variants: {
+        variant: {
+            default: "bg-coreColors-modalBackground [&_*]:text-textColors-primaryColor",
+            error: "bg-stateColors-error [&_*]:text-coreColors-pageColor",
+            warning: "bg-stateColors-warning [&_*]:text-coreColors-pageColor",
+            success: "bg-stateColors-success [&_*]:text-coreColors-pageColor",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+    },
+});
+const Toast = React.forwardRef((_a, ref) => {
+    var { className, variant } = _a, props = __rest(_a, ["className", "variant"]);
+    return (_jsx(ToastPrimitives.Root, Object.assign({ ref: ref, className: cn(toastVariants({ variant }), className) }, props), void 0));
+});
+Toast.displayName = ToastPrimitives.Root.displayName;
+const ToastAction = React.forwardRef((_a, ref) => {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(ToastPrimitives.Action, Object.assign({ ref: ref, className: cn("inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium ring-offset-background transition-colors hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive", className) }, props), void 0));
+});
+ToastAction.displayName = ToastPrimitives.Action.displayName;
+const ToastClose = React.forwardRef((_a, ref) => {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(ToastPrimitives.Close, Object.assign({ ref: ref, className: cn("absolute right-2 top-2 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-2 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600", className), "toast-close": "" }, props, { children: _jsx(X, { className: "h-4 w-4" }, void 0) }), void 0));
+});
+ToastClose.displayName = ToastPrimitives.Close.displayName;
+const ToastTitle = React.forwardRef((_a, ref) => {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(ToastPrimitives.Title, Object.assign({ ref: ref, className: cn("text-sm font-semibold", className) }, props), void 0));
+});
+ToastTitle.displayName = ToastPrimitives.Title.displayName;
+const ToastIcon = ({ type }) => {
+    const logoTypes = {
+        warning: {
+            name: "alert-circle",
+            color: "coreColors-pageColor",
+        },
+        error: {
+            name: "circle-x",
+            color: "coreColors-pageColor",
+        },
+        success: {
+            name: "check",
+            color: "coreColors-pageColor",
+        },
+        default: {
+            name: "info-circle",
+            color: "textColos-primaryColor",
+        },
+    };
+    const logoType = logoTypes[type];
+    return _jsx(Icon, { name: logoType.name || "", size: "sm", color: logoType.color }, void 0);
+};
+const ToastDescription = React.forwardRef((_a, ref) => {
+    var { className, type = "default", icon } = _a, props = __rest(_a, ["className", "type", "icon"]);
+    return (_jsxs(ToastPrimitives.Description, Object.assign({ ref: ref, className: cn("flex gap-4 items-center", className) }, props, { children: [icon ? _jsx(ToastIcon, { type: type }, void 0) : null, _jsx(Text, Object.assign({ type: "body-primary", className: "line-clamp-2" }, { children: props.children }), void 0)] }), void 0));
+});
+ToastDescription.displayName = ToastPrimitives.Description.displayName;
+export { ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };

package/dist/components/ui/toaster.d.ts

@@ -0,0 +1,6 @@
+export declare function Toaster({ type, }: {
+    type?: "default" | "warning" | "error" | "success";
+    description?: string;
+    icon?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=toaster.d.ts.map

package/dist/components/ui/toaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toaster.d.ts","sourceRoot":"","sources":["../../../components/ui/toaster.tsx"],"names":[],"mappings":"AAWA,wBAAgB,OAAO,CAAC,EACtB,IAAgB,GACjB,EAAE;IACD,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,2CAqBA"}

package/dist/components/ui/toaster.js

@@ -0,0 +1,22 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Toast, ToastDescription, ToastProvider, ToastTitle, ToastViewport, } from "../../components/ui/toast";
+import { useToast } from "../../components/ui/use-toast";
+export function Toaster({ type = "default", }) {
+    const { toasts } = useToast();
+    return (_jsxs(ToastProvider, { children: [toasts.map(function (_a) {
+                var { id, title, description, icon } = _a, props = __rest(_a, ["id", "title", "description", "icon"]);
+                return (_jsx(Toast, Object.assign({ variant: type }, props, { children: _jsxs("div", Object.assign({ className: "flex w-full justify-center" }, { children: [title && _jsx(ToastTitle, { children: title }, void 0), description && (_jsx(ToastDescription, Object.assign({ type: type, icon: icon }, { children: description }), void 0))] }), void 0) }), id));
+            }), _jsx(ToastViewport, {}, void 0)] }, void 0));
+}

package/dist/components/ui/toggle-group.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { VariantProps } from "class-variance-authority";
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "outline" | "default" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "outline" | "default" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };
+//# sourceMappingURL=toggle-group.d.ts.map

package/dist/components/ui/toggle-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle-group.d.ts","sourceRoot":"","sources":["../../../components/ui/toggle-group.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,oBAAoB,MAAM,8BAA8B,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAYvD,QAAA,MAAM,WAAW;;;4HAcf,CAAA;AAIF,QAAA,MAAM,eAAe;;;8HAsBnB,CAAA;AAIF,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,CAAA"}

package/dist/components/ui/toggle-group.js

@@ -0,0 +1,36 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import { cn } from "../../lib/utils";
+import { toggleVariants } from "../../components/ui/toggle";
+const ToggleGroupContext = React.createContext({
+    size: "default",
+    variant: "default",
+});
+const ToggleGroup = React.forwardRef((_a, ref) => {
+    var { className, variant, size, children } = _a, props = __rest(_a, ["className", "variant", "size", "children"]);
+    return (_jsx(ToggleGroupPrimitive.Root, Object.assign({ ref: ref, className: cn("flex items-center justify-center gap-1", className) }, props, { children: _jsx(ToggleGroupContext.Provider, Object.assign({ value: { variant, size } }, { children: children }), void 0) }), void 0));
+});
+ToggleGroup.displayName = ToggleGroupPrimitive.Root.displayName;
+const ToggleGroupItem = React.forwardRef((_a, ref) => {
+    var { className, children, variant, size } = _a, props = __rest(_a, ["className", "children", "variant", "size"]);
+    const context = React.useContext(ToggleGroupContext);
+    return (_jsx(ToggleGroupPrimitive.Item, Object.assign({ ref: ref, className: cn(toggleVariants({
+            variant: context.variant || variant,
+            size: context.size || size,
+        }), className) }, props, { children: children }), void 0));
+});
+ToggleGroupItem.displayName = ToggleGroupPrimitive.Item.displayName;
+export { ToggleGroup, ToggleGroupItem };

package/dist/components/ui/toggle.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { type VariantProps } from "class-variance-authority";
+declare const toggleVariants: (props?: ({
+    variant?: "outline" | "default" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "outline" | "default" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };
+//# sourceMappingURL=toggle.d.ts.map

package/dist/components/ui/toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.d.ts","sourceRoot":"","sources":["../../../components/ui/toggle.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,eAAe,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAIjE,QAAA,MAAM,cAAc;;;mFAoBnB,CAAA;AAED,QAAA,MAAM,MAAM;;;8HAUV,CAAA;AAIF,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA"}

package/dist/components/ui/toggle.js

@@ -0,0 +1,40 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { cva } from "class-variance-authority";
+import { cn } from "../../lib/utils";
+const toggleVariants = cva("inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground", {
+    variants: {
+        variant: {
+            default: "bg-transparent",
+            outline: "border border-input bg-transparent hover:bg-accent hover:text-accent-foreground",
+        },
+        size: {
+            default: "h-10 px-3",
+            sm: "h-9 px-2.5",
+            lg: "h-11 px-5",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+        size: "default",
+    },
+});
+const Toggle = React.forwardRef((_a, ref) => {
+    var { className, variant, size } = _a, props = __rest(_a, ["className", "variant", "size"]);
+    return (_jsx(TogglePrimitive.Root, Object.assign({ ref: ref, className: cn(toggleVariants({ variant, size, className })) }, props), void 0));
+});
+Toggle.displayName = TogglePrimitive.Root.displayName;
+export { Toggle, toggleVariants };

package/dist/components/ui/use-toast.d.ts

@@ -0,0 +1,45 @@
+import * as React from "react";
+import type { ToastProps } from "../../components/ui/toast";
+declare type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: boolean;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+declare type ActionType = typeof actionTypes;
+declare type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+declare type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string | undefined) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };
+//# sourceMappingURL=use-toast.d.ts.map

package/dist/components/ui/use-toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-toast.d.ts","sourceRoot":"","sources":["../../../components/ui/use-toast.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAK3E,aAAK,YAAY,GAAG,UAAU,GAAG;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACvB,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,QAAA,MAAM,WAAW;;;;;CAKP,CAAA;AASV,aAAK,UAAU,GAAG,OAAO,WAAW,CAAA;AAEpC,aAAK,MAAM,GACP;IACE,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAA;IAC7B,KAAK,EAAE,YAAY,CAAA;CACpB,GACD;IACE,IAAI,EAAE,UAAU,CAAC,cAAc,CAAC,CAAA;IAChC,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;CAC7B,GACD;IACE,IAAI,EAAE,UAAU,CAAC,eAAe,CAAC,CAAA;IACjC,OAAO,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,CAAA;CAC7B,GACD;IACE,IAAI,EAAE,UAAU,CAAC,cAAc,CAAC,CAAA;IAChC,OAAO,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,CAAA;CAC7B,CAAA;AAEL,UAAU,KAAK;IACb,MAAM,EAAE,YAAY,EAAE,CAAA;CACvB;AAoBD,eAAO,MAAM,OAAO,UAAW,KAAK,UAAU,MAAM,KAAG,KAqDtD,CAAA;AAaD,aAAK,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAA;AAErC,iBAAS,KAAK,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK;;;oBAGT,YAAY;EAwBpC;AAED,iBAAS,QAAQ;;;;EAkBhB;AAED,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA"}

package/dist/components/ui/use-toast.js

@@ -0,0 +1,112 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+// Inspired by react-hot-toast library
+import * as React from "react";
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+const actionTypes = {
+    ADD_TOAST: "ADD_TOAST",
+    UPDATE_TOAST: "UPDATE_TOAST",
+    DISMISS_TOAST: "DISMISS_TOAST",
+    REMOVE_TOAST: "REMOVE_TOAST",
+};
+let count = 0;
+function genId() {
+    count = (count + 1) % Number.MAX_SAFE_INTEGER;
+    return count.toString();
+}
+const toastTimeouts = new Map();
+const addToRemoveQueue = (toastId) => {
+    if (toastTimeouts.has(toastId)) {
+        return;
+    }
+    const timeout = setTimeout(() => {
+        toastTimeouts.delete(toastId);
+        dispatch({
+            type: "REMOVE_TOAST",
+            toastId: toastId,
+        });
+    }, TOAST_REMOVE_DELAY);
+    toastTimeouts.set(toastId, timeout);
+};
+export const reducer = (state, action) => {
+    switch (action.type) {
+        case "ADD_TOAST":
+            return Object.assign(Object.assign({}, state), { toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT) });
+        case "UPDATE_TOAST":
+            return Object.assign(Object.assign({}, state), { toasts: state.toasts.map((t) => t.id === action.toast.id ? Object.assign(Object.assign({}, t), action.toast) : t) });
+        case "DISMISS_TOAST": {
+            const { toastId } = action;
+            // ! Side effects ! - This could be extracted into a dismissToast() action,
+            // but I'll keep it here for simplicity
+            if (toastId) {
+                addToRemoveQueue(toastId);
+            }
+            else {
+                state.toasts.forEach((toast) => {
+                    addToRemoveQueue(toast.id);
+                });
+            }
+            return Object.assign(Object.assign({}, state), { toasts: state.toasts.map((t) => t.id === toastId || toastId === undefined
+                    ? Object.assign(Object.assign({}, t), { open: false }) : t) });
+        }
+        case "REMOVE_TOAST":
+            if (action.toastId === undefined) {
+                return Object.assign(Object.assign({}, state), { toasts: [] });
+            }
+            return Object.assign(Object.assign({}, state), { toasts: state.toasts.filter((t) => t.id !== action.toastId) });
+    }
+};
+const listeners = [];
+let memoryState = { toasts: [] };
+function dispatch(action) {
+    memoryState = reducer(memoryState, action);
+    listeners.forEach((listener) => {
+        listener(memoryState);
+    });
+}
+function toast(_a) {
+    var props = __rest(_a, []);
+    const id = genId();
+    const update = (props) => dispatch({
+        type: "UPDATE_TOAST",
+        toast: Object.assign(Object.assign({}, props), { id }),
+    });
+    const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+    dispatch({
+        type: "ADD_TOAST",
+        toast: Object.assign(Object.assign({}, props), { id, open: true, onOpenChange: (open) => {
+                if (!open)
+                    dismiss();
+            } }),
+    });
+    return {
+        id: id,
+        dismiss,
+        update,
+    };
+}
+function useToast() {
+    const [state, setState] = React.useState(memoryState);
+    React.useEffect(() => {
+        listeners.push(setState);
+        return () => {
+            const index = listeners.indexOf(setState);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    }, [state]);
+    return Object.assign(Object.assign({}, state), { toast, dismiss: (toastId) => dispatch({ type: "DISMISS_TOAST", toastId }) });
+}
+export { useToast, toast };

package/dist/components/ui/video.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const videoVariants: (props?: ({} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface VideoProps extends React.HTMLAttributes<HTMLVideoElement>, VariantProps<typeof videoVariants> {
+}
+declare function Video({ className, ...props }: VideoProps): import("react/jsx-runtime").JSX.Element;
+export { Video, videoVariants };
+//# sourceMappingURL=video.d.ts.map

package/dist/components/ui/video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../components/ui/video.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAIjE,QAAA,MAAM,aAAa,gGAEjB,CAAA;AAEF,MAAM,WAAW,UACf,SAAQ,KAAK,CAAC,cAAc,CAAC,gBAAgB,CAAC,EAC5C,YAAY,CAAC,OAAO,aAAa,CAAC;CAAG;AAEzC,iBAAS,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,EAAE,UAAU,2CAWjD;AAED,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,CAAA"}

package/dist/components/ui/video.js

@@ -0,0 +1,22 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { cn } from "../../lib/utils";
+const videoVariants = cva("w-full", {
+    variants: {},
+});
+function Video(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx("video", Object.assign({ className: cn(videoVariants({}), className) }, props, { autoPlay: true, playsInline: true, muted: true, loop: true }), void 0));
+}
+export { Video, videoVariants };

package/dist/components/ui/wishlist.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export interface WishlistProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    imgUrl?: string;
+    name: string;
+    amount: number;
+    selected?: boolean;
+    onClick?: () => void;
+    className?: string;
+}
+declare const Wishlist: React.ForwardRefExoticComponent<WishlistProps & React.RefAttributes<HTMLButtonElement>>;
+export { Wishlist };
+//# sourceMappingURL=wishlist.d.ts.map

package/dist/components/ui/wishlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wishlist.d.ts","sourceRoot":"","sources":["../../../components/ui/wishlist.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAO9B,MAAM,WAAW,aACf,SAAQ,KAAK,CAAC,oBAAoB,CAAC,iBAAiB,CAAC;IACrD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAQD,QAAA,MAAM,QAAQ,yFAuCb,CAAA;AAID,OAAO,EAAE,QAAQ,EAAE,CAAA"}