@infinityloop.labs/ui-kit 0.0.9 → 0.0.11

package/dist/components/atoms/Breadcrumbs/index.d.ts

@@ -0,0 +1 @@
+export { Breadcrumbs, type BreadcrumbsItemObjectType, type BreadcrumbsItemType, } from '../../../components/ui/breadcrumbs';

package/dist/components/atoms/Button/index.d.ts

@@ -1,10 +1,20 @@
-import { VariantProps } from 'class-variance-authority';
-import * as React from 'react';
-declare const buttonVariants: (props?: ({
-    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
-    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string;
-declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
-    asChild?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
-export { Button, buttonVariants };
+import type { ButtonHTMLAttributes, MouseEvent, PropsWithChildren, ReactNode } from 'react';
+type ButtonAnimationType = 'default' | 'active' | 'loading';
+type ButtonSizeType = 's' | 'm' | 'l' | 'icon-s' | 'icon-m' | 'icon-l' | 'default' | 'sm' | 'lg' | 'icon' | 'icon-sm' | 'icon-lg' | 'icon-circle';
+export declare const BUTTON_VARIANT_OPTIONS: readonly ["filled", "outline", "text"];
+export type ButtonVariantType = (typeof BUTTON_VARIANT_OPTIONS)[number];
+export declare const BUTTON_COLOR_OPTIONS: readonly ["primary", "secondary", "accent", "muted", "constructive", "cautionary", "destructive", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5"];
+export type ButtonColorType = (typeof BUTTON_COLOR_OPTIONS)[number];
+type ButtonPropertyType = PropsWithChildren<ButtonHTMLAttributes<HTMLButtonElement> & {
+    icon?: ReactNode;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
+    animation?: ButtonAnimationType;
+    isLoading?: boolean;
+    color?: ButtonColorType;
+    variant?: ButtonVariantType;
+    size?: ButtonSizeType;
+}>;
+export declare const Button: ({ icon, leftIcon, rightIcon, onClick, animation, isLoading, color, variant, size, className, children, style, ...property }: ButtonPropertyType) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/atoms/Dropdown/index.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+export type DropdownOptionType = {
+    value: string;
+    label: string;
+};
+type DropdownPropertyType = Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> & {
+    options: DropdownOptionType[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    label?: React.ReactNode;
+    required?: boolean;
+    isError?: boolean;
+    errorText?: React.ReactNode;
+    placeholder?: string;
+    isSearchable?: boolean;
+    searchPlaceholder?: string;
+    disabled?: boolean;
+    emptyText?: string;
+};
+export declare const Dropdown: ({ options, value, defaultValue, onValueChange, label, required, isError, errorText, placeholder, isSearchable, searchPlaceholder, disabled, emptyText, id, "aria-invalid": ariaInvalid, className, ...property }: DropdownPropertyType) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/atoms/Flex/index.d.ts

@@ -1,9 +1,8 @@
 import { HTMLAttributes } from 'react';
-import { JustifyContentType, AlignItemsType } from './lib/types';
-
-export declare const Flex: import('react').ForwardRefExoticComponent<{
+import type { JustifyContentType, AlignItemsType } from './lib/types';
+export declare const Flex: import("react").ForwardRefExoticComponent<{
     column?: boolean;
     middle?: boolean;
     'justify-content'?: JustifyContentType;
     'align-items'?: AlignItemsType;
-} & HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+} & HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/atoms/Grid/index.d.ts

@@ -1,5 +1,4 @@
 import { HTMLAttributes } from 'react';
-
-export declare const Grid: import('react').ForwardRefExoticComponent<{
+export declare const Grid: import("react").ForwardRefExoticComponent<{
     column?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
-} & HTMLAttributes<HTMLDivElement> & import('react').RefAttributes<HTMLDivElement>>;
+} & HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/atoms/Image/index.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+export declare const IMAGE_MASK_OPTIONS: readonly [{
+    readonly value: 0;
+    readonly label: "No Mask";
+}, {
+    readonly value: 1;
+    readonly label: "Octagon Crop";
+}, {
+    readonly value: 2;
+    readonly label: "Circle Crop";
+}, {
+    readonly value: 3;
+    readonly label: "Square Crop";
+}];
+export type ImageMaskType = (typeof IMAGE_MASK_OPTIONS)[number]['value'];
+export type ImageMaskPositionValueType = {
+    x: number;
+    y: number;
+};
+export type ImageCropPositionValueType = {
+    x: number;
+    y: number;
+};
+export declare const getImageMaskUrlByType: (maskType: number) => string | undefined;
+export type ImagePropertyType = Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'className'> & {
+    className?: string;
+    isLoading?: boolean;
+    maskType?: ImageMaskType;
+    isEditModeDisabled?: boolean;
+    imagePosition?: string;
+    isSquareCrop?: boolean;
+    cropX?: number;
+    cropY?: number;
+    cropPositionValue?: ImageCropPositionValueType;
+    defaultCropPositionValue?: ImageCropPositionValueType;
+    onCropPositionChange?: (value: ImageCropPositionValueType) => void;
+    maskSize?: string;
+    maskPositionValue?: ImageMaskPositionValueType;
+    maskFillColor?: string;
+    maskStrokeColor?: string;
+    maskStrokeWidth?: number;
+    isTopShadeVisible?: boolean;
+    topShadeColor?: string;
+    isBottomShadeVisible?: boolean;
+    bottomShadeColor?: string;
+};
+export declare const Image: ({ className, isLoading, maskType, isEditModeDisabled, imagePosition, isSquareCrop, cropX, cropY, cropPositionValue, defaultCropPositionValue, onCropPositionChange, maskSize, maskPositionValue, maskFillColor, maskStrokeColor, maskStrokeWidth, isTopShadeVisible, topShadeColor, isBottomShadeVisible, bottomShadeColor, alt, style, ...property }: ImagePropertyType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/atoms/Input/index.d.ts

@@ -1,3 +1,24 @@
 import * as React from 'react';
-declare function Input({ className, type, ...props }: React.ComponentProps<'input'>): import("react/jsx-runtime").JSX.Element;
+import { type TypographyType } from '../../../components/atoms/Typography';
+export type InputVariantType = 'outline' | 'text';
+type InputSharedPropertyType = {
+    className?: string;
+    variant?: InputVariantType;
+    typography?: TypographyType;
+    isTextarea?: boolean;
+    isResizableX?: boolean;
+    isResizableY?: boolean;
+    textareaRowsCount?: number;
+    isError?: boolean;
+    label?: React.ReactNode;
+    errorText?: React.ReactNode;
+};
+type SingleLineInputPropertyType = InputSharedPropertyType & React.ComponentProps<'input'> & {
+    isTextarea?: false;
+};
+type MultiLineInputPropertyType = InputSharedPropertyType & Omit<React.ComponentProps<'textarea'>, 'rows' | 'type'> & {
+    isTextarea: true;
+};
+type InputPropertyType = SingleLineInputPropertyType | MultiLineInputPropertyType;
+declare function Input(property: InputPropertyType): import("react/jsx-runtime").JSX.Element;
 export { Input };

package/dist/components/atoms/Paper/index.d.ts

@@ -1,5 +1,19 @@
-export type PaperPropertyType = {
+import type { ComponentPropsWithoutRef, ElementType, PropsWithChildren } from 'react';
+declare const paperStyleDictionary: {
+    readonly light: "bg-(--card)";
+    readonly dark: "bg-(--background)";
+    readonly gradient: "bg-[radial-gradient(120%_120%_at_0%_0%,color-mix(in_oklab,var(--chart-1)_10%,transparent),transparent_55%),linear-gradient(180deg,color-mix(in_oklab,var(--card)_93%,black_7%),var(--card))]";
+};
+type PaperType = keyof typeof paperStyleDictionary;
+type PaperBasePropertyType<T extends ElementType> = {
+    as?: T;
+    type?: PaperType;
     className?: string;
-    color?: 'white' | 'gray';
+    isColored?: boolean;
+    isRoundedCornersDisabled?: boolean;
+    isLoading?: boolean;
 };
-export declare const Paper: FC<PaperPropertyType>;
+type PaperPropertyType<T extends ElementType> = PropsWithChildren<PaperBasePropertyType<T> & Omit<ComponentPropsWithoutRef<T>, 'as' | 'className' | 'children'>>;
+declare const defaultElement = "div";
+export declare const Paper: <T extends ElementType = typeof defaultElement>({ as, type, className, children, isColored, isRoundedCornersDisabled, isLoading, ...property }: PaperPropertyType<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/atoms/Tag/index.d.ts

@@ -0,0 +1,15 @@
+import { type HTMLAttributes } from 'react';
+import { type TypographyColorType } from '../../../components/atoms/Typography';
+export declare const TAG_TYPE_OPTIONS: readonly ["default", "time"];
+export type TagType = (typeof TAG_TYPE_OPTIONS)[number];
+export type TagPropertyType = HTMLAttributes<HTMLSpanElement> & {
+    label: string;
+    type?: TagType;
+    color?: TypographyColorType;
+    textColor?: TypographyColorType;
+    isLoading?: boolean;
+    isEditModeEnabled?: boolean;
+    isEditModeDisabled?: boolean;
+    onLabelChange?: (value: string) => void;
+};
+export declare const Tag: ({ label, type, color, textColor, className, isLoading, isEditModeEnabled, isEditModeDisabled, onLabelChange, ...property }: TagPropertyType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/atoms/Timer/index.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+type TimerLabelsType = {
+    days: React.ReactNode;
+    hours: React.ReactNode;
+    minutes: React.ReactNode;
+    seconds: React.ReactNode;
+};
+export type TimerPropertyType = {
+    targetDate: Date | number | string;
+    className?: string;
+    itemClassName?: string;
+    labels?: Partial<TimerLabelsType>;
+    onComplete?: () => void;
+};
+export declare const Timer: {
+    ({ targetDate, className, itemClassName, labels, onComplete, }: TimerPropertyType): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/components/atoms/Toggle/index.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+type TogglePropertyType = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'className'> & {
+    className?: string;
+    leftLabel?: React.ReactNode;
+    rightLabel?: React.ReactNode;
+    labelClassName?: string;
+};
+export declare const Toggle: ({ className, leftLabel, rightLabel, labelClassName, id, disabled, ...property }: TogglePropertyType) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/atoms/Typography/index.d.ts

@@ -1,11 +1,21 @@
-import { FC, AnchorHTMLAttributes } from 'react';
-
-export type TypographyType = 'H1SemiBold' | 'H2SemiBold' | 'H3Medium' | 'H3SemiBold' | 'H4SemiBold' | 'MRegular' | 'MMedium' | 'MSemiBold' | 'SRegular' | 'SMedium' | 'SSemiBold' | 'XSMedium' | 'MonoMRegular' | 'MonoSRegular' | 'Heading32' | 'Heading24' | 'Heading20' | 'Heading16' | 'Heading14' | 'Heading12' | 'SemiBold52' | 'SemiBold48' | 'SemiBold40' | 'SemiBold32' | 'SemiBold24' | 'SemiBold20' | 'SemiBold16' | 'SemiBold14' | 'Regular24' | 'Regular20' | 'Regular16' | 'Regular14' | 'Regular12' | 'Mono16';
-type ElementType = 'a' | 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'span';
+import React, { type ElementType, type HTMLAttributes } from 'react';
+export type TypographyType = 'Heading' | 'SectionHeader' | 'CompactHeader' | 'Action' | 'Subheader' | 'Body' | 'BodySmall' | 'Caption' | 'CompactCaption';
+export declare const TYPOGRAPHY_COLOR_OPTIONS: readonly ["background", "foreground", "card", "card-foreground", "popover", "popover-foreground", "muted-foreground", "muted", "primary", "primary-foreground", "secondary", "secondary-foreground", "accent", "accent-foreground", "destructive", "constructive", "constructive-foreground", "cautionary", "cautionary-foreground", "border", "input", "ring", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5"];
+export type TypographyColorType = (typeof TYPOGRAPHY_COLOR_OPTIONS)[number];
+export declare const TYPOGRAPHY_OPTIONS: TypographyType[];
+export declare const getTypographyClassName: (typography: TypographyType) => string;
+export declare const getDefaultElementTagByTypography: (typography: TypographyType) => "h1" | "h4" | "h5" | "p" | "span";
+export declare const getDefaultColorByTypography: (typography: TypographyType) => "foreground" | "muted-foreground";
+export declare const getPlaceholderTypographyClassName: (typography: TypographyType) => string;
 type OwnPropertyType = {
     typography: TypographyType;
     element?: ElementType;
+    color?: TypographyColorType;
     className?: string;
-} & AnchorHTMLAttributes<HTMLAnchorElement>;
-export declare const Typography: FC<OwnPropertyType>;
+    isLoading?: boolean;
+} & HTMLAttributes<HTMLElement>;
+export declare const Typography: {
+    ({ typography, element, color, style, className: clsname, isLoading, children, ...props }: OwnPropertyType): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    displayName: string;
+};
 export {};

package/dist/components/atoms/index.d.ts

@@ -2,5 +2,11 @@ export * from './Flex';
 export * from './Grid';
 export * from './Typography';
 export * from './Paper';
+export * from './Breadcrumbs';
 export * from './Button';
 export * from './Input';
+export * from './Dropdown';
+export * from './Toggle';
+export * from './Image';
+export * from './Timer';
+export * from './Tag';

package/dist/components/index.d.ts

@@ -1,2 +1,4 @@
 export * from './atoms';
+export * from './molecules';
 export * from './ui';
+export * from './ui/shadcn-io/color-picker';

package/dist/components/molecules/EditableTypography/index.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { ElementType } from 'react';
+import { type TypographyColorType, type TypographyType } from '../../../components/atoms/Typography';
+type EditableTypographyPropertyType = {
+    className?: string;
+    typography?: TypographyType;
+    element?: ElementType;
+    color?: TypographyColorType;
+    isEditModeDisabled?: boolean;
+    isLoading?: boolean;
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    onValueChange?: (value: string) => void;
+    children?: React.ReactNode;
+};
+export declare const EditableTypography: ({ className, typography, element, color, isEditModeDisabled, isLoading, value, defaultValue, placeholder, onValueChange, children, }: EditableTypographyPropertyType) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/molecules/SlideTemplates/StoreSlide/index.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { type ImagePropertyType } from '../../../../components/atoms/Image';
+import { type TagType } from '../../../../components/atoms/Tag';
+import { type TypographyColorType } from '../../../../components/atoms/Typography';
+export type StoreSlideImageChangePayloadType = {
+    file: File;
+    objectUrl: string;
+};
+export type StoreSlideTagItemType = {
+    id: string;
+    label: string;
+    type?: TagType;
+    position?: 'top-left' | 'bottom-right';
+    color?: TypographyColorType;
+    textColor?: TypographyColorType;
+    isLoading?: boolean;
+    onClick?: (id: string) => void;
+    onLabelChange?: (id: string, value: string) => void;
+};
+export type StoreSlidePropertyType = Omit<React.HTMLAttributes<HTMLElement>, 'title'> & {
+    isSetModeEnabled?: boolean;
+    isEditModeEnabled?: boolean;
+    isEditModeDisabled?: boolean;
+    setModelEnabled?: boolean;
+    coverImageSrc: string;
+    coverImageAlt?: string;
+    isImageLoading?: boolean;
+    imageProps?: Omit<ImagePropertyType, 'src' | 'alt' | 'className'>;
+    imageAccept?: string;
+    onImageChange?: (payload: StoreSlideImageChangePayloadType) => void;
+    brandName: React.ReactNode;
+    brandIcon?: React.ReactNode;
+    heading: React.ReactNode;
+    accentText?: React.ReactNode;
+    description?: React.ReactNode;
+    priceText: React.ReactNode;
+    tagText?: string;
+    tagType?: TagType;
+    tagColor?: TypographyColorType;
+    tagTextColor?: TypographyColorType;
+    tags?: StoreSlideTagItemType[];
+    onTagClick?: (id: string) => void;
+    onTagLabelChange?: (id: string, value: string) => void;
+    badgeText?: React.ReactNode;
+};
+export declare const StoreSlide: ({ className, isSetModeEnabled, isEditModeEnabled, isEditModeDisabled, setModelEnabled, coverImageSrc, coverImageAlt, isImageLoading, imageProps, imageAccept, onImageChange, brandName, brandIcon, heading, accentText, description, priceText, tagText, tagType, tagColor, tagTextColor, tags, onTagClick, onTagLabelChange, badgeText, ...property }: StoreSlidePropertyType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/molecules/SlideTemplates/index.d.ts

@@ -0,0 +1 @@
+export * from './StoreSlide';

package/dist/components/molecules/Slider/index.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+type SliderPropertyType = Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> & {
+    slides: React.ReactNode[];
+    slidesPerView?: number | 'auto';
+    spaceBetween?: number;
+    isLoopEnabled?: boolean;
+    isPaginationVisible?: boolean;
+    isNavigationVisible?: boolean;
+    isNavigationEnabled?: boolean;
+    isArrowsVisible?: boolean;
+    isMousewheelEnabled?: boolean;
+    isKeyboardEnabled?: boolean;
+    isGrabCursorVisible?: boolean;
+    isFreeScrollEnabled?: boolean;
+    onSlideChange?: (activeSlideIndex: number) => void;
+};
+export declare const Slider: ({ slides, className, slidesPerView, spaceBetween, isLoopEnabled, isPaginationVisible, isNavigationVisible, isNavigationEnabled, isArrowsVisible, isMousewheelEnabled, isKeyboardEnabled, isGrabCursorVisible, isFreeScrollEnabled, onSlideChange, ...property }: SliderPropertyType) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/molecules/Slider/slides/MediumHorizontalSlide.d.ts

@@ -0,0 +1,10 @@
+export type MediumHorizontalSlidePropertyType = {
+    coverImageSrc: string;
+    brandName: string;
+    heading: string;
+    viewsText: string;
+    tagText?: string;
+    isEditModeEnabled?: boolean;
+    isEditModeDisabled?: boolean;
+};
+export declare const MediumHorizontalSlide: ({ coverImageSrc, brandName, heading, viewsText, tagText, isEditModeEnabled, isEditModeDisabled, }: MediumHorizontalSlidePropertyType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/molecules/Slider/slides/MediumVerticalSlide.d.ts

@@ -0,0 +1,3 @@
+import { type StoreSlidePropertyType } from '../../../../components/molecules/SlideTemplates';
+export type MediumVerticalSlidePropertyType = StoreSlidePropertyType;
+export declare const MediumVerticalSlide: (property: MediumVerticalSlidePropertyType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/molecules/Slider/slides/examples.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { StoreSlideTagItemType } from '../../../../components/molecules/SlideTemplates';
+export type SliderDemoSlideItemType = {
+    id: string;
+    coverImageSrc: string;
+    brandName: string;
+    heading: string;
+    accentText: string;
+    description: string;
+    priceText: string;
+    tagText: string;
+};
+export declare const courseSlideData: SliderDemoSlideItemType[];
+export declare const sliderSlideComponentTypeOptions: readonly ["MediumVerticalSlide", "MediumHorizontalSlide"];
+export type SliderSlideComponentType = (typeof sliderSlideComponentTypeOptions)[number];
+export declare const mediumVerticalSlideWidthClassName = "w-[460px] min-w-[460px]";
+export declare const mediumHorizontalSlideWidthClassName = "w-[520px] min-w-[520px]";
+type TagVariantType = 'no-tags' | 'one-tag' | 'two-tags' | 'two-other-tags';
+export declare const getTagsByVariant: (variant: TagVariantType, slideId: string, baseLabel: string) => {
+    tags: StoreSlideTagItemType[];
+    tagText?: string;
+};
+export type BuildSliderSlidesPropertyType = {
+    componentType: SliderSlideComponentType;
+    isEditModeEnabled?: boolean;
+    isEditModeDisabled?: boolean;
+    onTagClick?: (id: string) => void;
+    onTagLabelChange?: (id: string, value: string) => void;
+};
+export declare const buildSliderSlides: ({ componentType, isEditModeEnabled, isEditModeDisabled, onTagClick, onTagLabelChange, }: BuildSliderSlidesPropertyType) => React.ReactNode[];
+export {};

package/dist/components/molecules/Slider/slides/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MediumHorizontalSlide';
+export * from './MediumVerticalSlide';
+export * from './examples';

package/dist/components/molecules/index.d.ts

@@ -0,0 +1,4 @@
+export * from './EditableTypography';
+export * from './Slider';
+export * from './Slider/slides';
+export * from './SlideTemplates';

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

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export type BreadcrumbsItemObjectType = {
+    key?: React.Key;
+    label?: React.ReactNode;
+    href?: string;
+    onClick?: React.ComponentProps<'a'>['onClick'];
+    isCurrent?: boolean;
+    component?: React.ReactElement;
+};
+export type BreadcrumbsItemType = BreadcrumbsItemObjectType | React.ReactElement;
+type BreadcrumbsPropertyType = React.ComponentProps<'nav'> & {
+    items: BreadcrumbsItemType[];
+    maxItems?: number;
+    separator?: React.ReactNode;
+    listClassName?: string;
+};
+export declare const Breadcrumbs: ({ items, maxItems, separator, listClassName, ...props }: BreadcrumbsPropertyType) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,2 +1,3 @@
 export * from './breadcrumb';
+export * from './breadcrumbs';
 export * from './avatar';

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, position, align, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/components/ui/shadcn-io/color-picker/index.d.ts

@@ -0,0 +1,37 @@
+import Color from 'color';
+import { Slider } from 'radix-ui';
+import { type ComponentProps, type HTMLAttributes } from 'react';
+import { Button } from '../../../../components/atoms/Button';
+import { SelectTrigger } from '../../../../components/ui/select';
+interface ColorPickerContextValue {
+    hue: number;
+    saturation: number;
+    lightness: number;
+    alpha: number;
+    mode: string;
+    setHue: (hue: number) => void;
+    setSaturation: (saturation: number) => void;
+    setLightness: (lightness: number) => void;
+    setAlpha: (alpha: number) => void;
+    setMode: (mode: string) => void;
+}
+export declare const useColorPicker: () => ColorPickerContextValue;
+export type ColorPickerProps = HTMLAttributes<HTMLDivElement> & {
+    value?: Parameters<typeof Color>[0];
+    defaultValue?: Parameters<typeof Color>[0];
+    onChange?: (value: Parameters<typeof Color.rgb>[0]) => void;
+};
+export declare const ColorPicker: ({ value, defaultValue, onChange, className, ...props }: ColorPickerProps) => import("react/jsx-runtime").JSX.Element;
+export type ColorPickerSelectionProps = HTMLAttributes<HTMLDivElement>;
+export declare const ColorPickerSelection: import("react").MemoExoticComponent<({ className, ...props }: ColorPickerSelectionProps) => import("react/jsx-runtime").JSX.Element>;
+export type ColorPickerHueProps = ComponentProps<typeof Slider.Root>;
+export declare const ColorPickerHue: ({ className, ...props }: ColorPickerHueProps) => import("react/jsx-runtime").JSX.Element;
+export type ColorPickerAlphaProps = ComponentProps<typeof Slider.Root>;
+export declare const ColorPickerAlpha: ({ className, ...props }: ColorPickerAlphaProps) => import("react/jsx-runtime").JSX.Element;
+export type ColorPickerEyeDropperProps = ComponentProps<typeof Button>;
+export declare const ColorPickerEyeDropper: ({ className, ...props }: ColorPickerEyeDropperProps) => import("react/jsx-runtime").JSX.Element;
+export type ColorPickerOutputProps = ComponentProps<typeof SelectTrigger>;
+export declare const ColorPickerOutput: ({ className, ...props }: ColorPickerOutputProps) => import("react/jsx-runtime").JSX.Element;
+export type ColorPickerFormatProps = HTMLAttributes<HTMLDivElement>;
+export declare const ColorPickerFormat: ({ className, ...props }: ColorPickerFormatProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/constants/css.d.ts

@@ -0,0 +1,4 @@
+export declare const HIDDEN_BY_SCROLL_CLASS = "opacity-0 pointer-events-none";
+export declare const FAST_TRANSITION_CLASS = "transition-all duration-300";
+export declare const GLASS_CLASS = "backdrop-blur-xl bg-opacity-95";
+export declare const GLASS_SURFACE_CLASS = "bg-(--card)/95 border border-(--border) backdrop-blur-xl";

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export * from "./css";

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-
 export * from './components';
+export * from './constants';