@codefast/ui 0.0.66 → 0.0.68

package/src/react/carousel.tsx

@@ -1,299 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import useEmblaCarousel, { type UseEmblaCarouselType } from 'embla-carousel-react';
-import { ArrowLeftIcon, ArrowRightIcon } from '@radix-ui/react-icons';
-import { createContextScope, type Scope } from '@radix-ui/react-context';
-import { cn } from '../lib/utils';
-import { Button, type ButtonProps } from './button';
-
-/* -----------------------------------------------------------------------------
- * Context: Carousel
- * -------------------------------------------------------------------------- */
-
-const CAROUSEL_NAME = 'Carousel';
-
-type ScopedProps<P> = P & { __scopeCarousel?: Scope };
-
-const [createCarouselContext] = createContextScope(CAROUSEL_NAME);
-
-type CarouselApi = UseEmblaCarouselType[1];
-type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
-type CarouselOptions = UseCarouselParameters[0];
-type CarouselPlugin = UseCarouselParameters[1];
-
-interface BaseCarouselProps {
-  opts?: CarouselOptions;
-  orientation?: 'horizontal' | 'vertical';
-  plugins?: CarouselPlugin;
-  setApi?: (api: CarouselApi) => void;
-}
-
-type CarouselContextValue = {
-  api: ReturnType<typeof useEmblaCarousel>[1];
-  canScrollNext: boolean;
-  canScrollPrev: boolean;
-  carouselRef: ReturnType<typeof useEmblaCarousel>[0];
-  scrollNext: () => void;
-  scrollPrev: () => void;
-} & BaseCarouselProps;
-
-const [CarouselProvider, useCarouselContext] = createCarouselContext<CarouselContextValue>(CAROUSEL_NAME);
-
-/* -----------------------------------------------------------------------------
- * Component: Carousel
- * -------------------------------------------------------------------------- */
-
-type CarouselElement = HTMLDivElement;
-type CarouselProps = React.HTMLAttributes<HTMLDivElement> & BaseCarouselProps;
-
-const Carousel = React.forwardRef<CarouselElement, CarouselProps>(
-  (
-    { __scopeCarousel, children, orientation, opts, setApi, plugins, className, ...props }: ScopedProps<CarouselProps>,
-    forwardedRef,
-  ) => {
-    const [carouselRef, api] = useEmblaCarousel(
-      {
-        ...opts,
-        axis: orientation === 'vertical' ? 'y' : 'x',
-      },
-      plugins,
-    );
-
-    const [canScrollPrev, setCanScrollPrev] = React.useState(false);
-    const [canScrollNext, setCanScrollNext] = React.useState(false);
-
-    const onSelect = React.useCallback((carouselApi: CarouselApi) => {
-      if (!carouselApi) {
-        return;
-      }
-
-      setCanScrollPrev(carouselApi.canScrollPrev());
-      setCanScrollNext(carouselApi.canScrollNext());
-    }, []);
-
-    const scrollPrev = React.useCallback(() => {
-      api?.scrollPrev();
-    }, [api]);
-
-    const scrollNext = React.useCallback(() => {
-      api?.scrollNext();
-    }, [api]);
-
-    const handleKeyDown = React.useCallback(
-      (event: React.KeyboardEvent<HTMLDivElement>) => {
-        if (event.key === 'ArrowLeft') {
-          event.preventDefault();
-          scrollPrev();
-        } else if (event.key === 'ArrowRight') {
-          event.preventDefault();
-          scrollNext();
-        }
-      },
-      [scrollPrev, scrollNext],
-    );
-
-    React.useEffect(() => {
-      if (!api || !setApi) {
-        return;
-      }
-
-      setApi(api);
-    }, [api, setApi]);
-
-    React.useEffect(() => {
-      if (!api) {
-        return;
-      }
-
-      onSelect(api);
-      api.on('reInit', onSelect);
-      api.on('select', onSelect);
-
-      return () => {
-        api.off('select', onSelect);
-      };
-    }, [api, onSelect]);
-
-    return (
-      <CarouselProvider
-        api={api}
-        canScrollNext={canScrollNext}
-        canScrollPrev={canScrollPrev}
-        carouselRef={carouselRef}
-        opts={opts}
-        orientation={orientation ?? (opts?.axis === 'y' ? 'vertical' : 'horizontal')}
-        scope={__scopeCarousel}
-        scrollNext={scrollNext}
-        scrollPrev={scrollPrev}
-      >
-        <div
-          ref={forwardedRef}
-          aria-roledescription="carousel"
-          className={cn('relative', className)}
-          role="region"
-          onKeyDownCapture={handleKeyDown}
-          {...props}
-        >
-          {children}
-        </div>
-      </CarouselProvider>
-    );
-  },
-);
-
-Carousel.displayName = CAROUSEL_NAME;
-
-/* -----------------------------------------------------------------------------
- * Component: CarouselContent
- * -------------------------------------------------------------------------- */
-
-const CAROUSEL_CONTENT_NAME = 'CarouselContent';
-
-type CarouselContentElement = HTMLDivElement;
-type CarouselContentProps = React.HTMLAttributes<HTMLDivElement>;
-
-const CarouselContent = React.forwardRef<CarouselContentElement, CarouselContentProps>(
-  ({ __scopeCarousel, className, ...props }: ScopedProps<CarouselContentProps>, forwardedRef) => {
-    const { carouselRef, orientation } = useCarouselContext(CAROUSEL_CONTENT_NAME, __scopeCarousel);
-
-    return (
-      <div ref={carouselRef} className="overflow-hidden">
-        <div
-          ref={forwardedRef}
-          className={cn('flex', orientation === 'horizontal' ? '-ml-4' : '-mt-4 flex-col', className)}
-          {...props}
-        />
-      </div>
-    );
-  },
-);
-
-CarouselContent.displayName = CAROUSEL_CONTENT_NAME;
-
-/* -----------------------------------------------------------------------------
- * Component: CarouselItem
- * -------------------------------------------------------------------------- */
-
-const CAROUSEL_ITEM_NAME = 'CarouselItem';
-
-type CarouselItemElement = HTMLDivElement;
-type CarouselItemProps = React.HTMLAttributes<HTMLDivElement>;
-
-const CarouselItem = React.forwardRef<CarouselItemElement, CarouselItemProps>(
-  ({ __scopeCarousel, className, ...props }: ScopedProps<CarouselItemProps>, forwardedRef) => {
-    const { orientation } = useCarouselContext(CAROUSEL_ITEM_NAME, __scopeCarousel);
-
-    return (
-      <div
-        ref={forwardedRef}
-        aria-roledescription="slide"
-        className={cn('min-w-0 shrink-0 grow-0 basis-full', orientation === 'horizontal' ? 'pl-4' : 'pt-4', className)}
-        role="group"
-        {...props}
-      />
-    );
-  },
-);
-
-CarouselItem.displayName = CAROUSEL_ITEM_NAME;
-
-/* -----------------------------------------------------------------------------
- * Component: CarouselPrevious
- * -------------------------------------------------------------------------- */
-
-const CAROUSEL_PREVIOUS_NAME = 'CarouselPrevious';
-
-type CarouselPreviousElement = HTMLButtonElement;
-type CarouselPreviousProps = ButtonProps;
-
-const CarouselPrevious = React.forwardRef<CarouselPreviousElement, CarouselPreviousProps>(
-  (
-    { __scopeCarousel, className, variant = 'outline', size = 'icon', ...props }: ScopedProps<CarouselPreviousProps>,
-    forwardedRef,
-  ) => {
-    const { orientation, scrollPrev, canScrollPrev } = useCarouselContext(CAROUSEL_PREVIOUS_NAME, __scopeCarousel);
-
-    return (
-      <Button
-        ref={forwardedRef}
-        className={cn(
-          'absolute size-8 rounded-full',
-          orientation === 'horizontal'
-            ? '-left-12 top-1/2 -translate-y-1/2'
-            : '-top-12 left-1/2 -translate-x-1/2 rotate-90',
-          className,
-        )}
-        disabled={!canScrollPrev}
-        size={size}
-        variant={variant}
-        onClick={scrollPrev}
-        {...props}
-      >
-        <ArrowLeftIcon className="size-4" />
-        <span className="sr-only">Previous slide</span>
-      </Button>
-    );
-  },
-);
-
-CarouselPrevious.displayName = CAROUSEL_PREVIOUS_NAME;
-
-/* -----------------------------------------------------------------------------
- * Component: CarouselNext
- * -------------------------------------------------------------------------- */
-
-const CAROUSEL_NEXT_NAME = 'CarouselNext';
-
-type CarouselNextElement = HTMLButtonElement;
-type CarouselNextProps = ButtonProps;
-
-const CarouselNext = React.forwardRef<CarouselNextElement, CarouselNextProps>(
-  (
-    { __scopeCarousel, className, variant = 'outline', size = 'icon', ...props }: ScopedProps<CarouselNextProps>,
-    forwardedRef,
-  ) => {
-    const { orientation, scrollNext, canScrollNext } = useCarouselContext(CAROUSEL_NEXT_NAME, __scopeCarousel);
-
-    return (
-      <Button
-        ref={forwardedRef}
-        className={cn(
-          'absolute size-8 rounded-full',
-          orientation === 'horizontal'
-            ? '-right-12 top-1/2 -translate-y-1/2'
-            : '-bottom-12 left-1/2 -translate-x-1/2 rotate-90',
-          className,
-        )}
-        disabled={!canScrollNext}
-        size={size}
-        variant={variant}
-        onClick={scrollNext}
-        {...props}
-      >
-        <ArrowRightIcon className="size-4" />
-        <span className="sr-only">Next slide</span>
-      </Button>
-    );
-  },
-);
-
-CarouselNext.displayName = CAROUSEL_NEXT_NAME;
-
-/* -----------------------------------------------------------------------------
- * Exports
- * -------------------------------------------------------------------------- */
-
-export {
-  type CarouselApi,
-  Carousel,
-  CarouselContent,
-  CarouselItem,
-  CarouselPrevious,
-  CarouselNext,
-  type CarouselProps,
-  type CarouselContentProps,
-  type CarouselItemProps,
-  type CarouselPreviousProps,
-  type CarouselNextProps,
-};

package/src/react/checkbox-cards.tsx

@@ -1,61 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { CheckIcon } from '@radix-ui/react-icons';
-import { cn } from '../lib/utils';
-import * as CheckboxGroupPrimitive from './checkbox-group.primitive';
-
-/* -----------------------------------------------------------------------------
- * Component: CheckboxCards
- * -------------------------------------------------------------------------- */
-
-type CheckboxCardsElement = React.ElementRef<typeof CheckboxGroupPrimitive.Root>;
-type CheckboxCardsProps = React.ComponentPropsWithoutRef<typeof CheckboxGroupPrimitive.Root>;
-
-const CheckboxCards = React.forwardRef<CheckboxCardsElement, CheckboxCardsProps>(
-  ({ className, ...props }, forwardedRef) => {
-    return <CheckboxGroupPrimitive.Root className={cn('grid gap-2', className)} {...props} ref={forwardedRef} />;
-  },
-);
-
-CheckboxCards.displayName = CheckboxGroupPrimitive.Root.displayName;
-
-/* -----------------------------------------------------------------------------
- * Component: CheckboxCardsItem
- * -------------------------------------------------------------------------- */
-
-type CheckboxCardsItemElement = React.ElementRef<typeof CheckboxGroupPrimitive.Item>;
-
-interface CheckboxCardsItemProps extends React.ComponentPropsWithoutRef<typeof CheckboxGroupPrimitive.Item> {
-  checkboxClassName?: string;
-}
-
-const CheckboxCardsItem = React.forwardRef<CheckboxCardsItemElement, CheckboxCardsItemProps>(
-  ({ children, className, checkboxClassName, ...props }, forwardedRef) => {
-    return (
-      <label className={cn('flex items-center justify-center gap-4 rounded-md border p-4', className)}>
-        {children}
-        <CheckboxGroupPrimitive.Item
-          ref={forwardedRef}
-          className={cn(
-            'border-input aria-checked:border-primary aria-checked:bg-primary aria-checked:text-primary-foreground peer flex size-4 shrink-0 cursor-pointer rounded-sm border shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 disabled:cursor-default disabled:opacity-50',
-            checkboxClassName,
-          )}
-          {...props}
-        >
-          <CheckboxGroupPrimitive.CheckboxGroupIndicator className="flex size-full items-center justify-center text-current">
-            <CheckIcon className="size-3.5" />
-          </CheckboxGroupPrimitive.CheckboxGroupIndicator>
-        </CheckboxGroupPrimitive.Item>
-      </label>
-    );
-  },
-);
-
-CheckboxCardsItem.displayName = CheckboxGroupPrimitive.Item.displayName;
-
-/* -----------------------------------------------------------------------------
- * Exports
- * -------------------------------------------------------------------------- */
-
-export { CheckboxCards, CheckboxCardsItem, type CheckboxCardsProps, type CheckboxCardsItemProps };

package/src/react/checkbox-group.primitive.tsx

@@ -1,206 +0,0 @@
-import * as React from 'react';
-import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
-import { createCheckboxScope } from '@radix-ui/react-checkbox';
-import { createContextScope, type Scope } from '@radix-ui/react-context';
-import * as RovingFocusGroup from '@radix-ui/react-roving-focus';
-import { createRovingFocusGroupScope } from '@radix-ui/react-roving-focus';
-import { useControllableState } from '@radix-ui/react-use-controllable-state';
-import { useDirection } from '@radix-ui/react-direction';
-import { Primitive } from '@radix-ui/react-primitive';
-
-/* -------------------------------------------------------------------------------------------------
- * Component: CheckboxGroup
- * -----------------------------------------------------------------------------------------------*/
-
-const CHECKBOX_GROUP_NAME = 'CheckboxGroup';
-
-type ScopedProps<P> = P & { __scopeCheckboxGroup?: Scope };
-
-const [createCheckboxGroupContext, createCheckboxGroupScope] = createContextScope(CHECKBOX_GROUP_NAME, [
-  createRovingFocusGroupScope,
-  createCheckboxScope,
-]);
-
-const useRovingFocusGroupScope = createRovingFocusGroupScope();
-const useCheckboxScope = createCheckboxScope();
-
-interface CheckboxGroupContextValue {
-  disabled: boolean;
-  onItemCheck: (value: string) => void;
-  onItemUncheck: (value: string) => void;
-  required: boolean;
-  name?: string;
-  value?: string[];
-}
-
-const [CheckboxGroupProvider, useCheckboxGroupContext] =
-  createCheckboxGroupContext<CheckboxGroupContextValue>(CHECKBOX_GROUP_NAME);
-
-type CheckboxGroupElement = React.ElementRef<typeof Primitive.div>;
-
-interface CheckboxGroupProps extends React.ComponentPropsWithoutRef<typeof Primitive.div> {
-  defaultValue?: string[];
-  dir?: RovingFocusGroup.RovingFocusGroupProps['dir'];
-  disabled?: React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>['disabled'];
-  loop?: RovingFocusGroup.RovingFocusGroupProps['loop'];
-  name?: CheckboxGroupContextValue['name'];
-  onValueChange?: (value: string[]) => void;
-  orientation?: RovingFocusGroup.RovingFocusGroupProps['orientation'];
-  required?: React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>['required'];
-  value?: CheckboxGroupContextValue['value'];
-}
-
-const CheckboxGroup = React.forwardRef<CheckboxGroupElement, CheckboxGroupProps>(
-  (
-    {
-      __scopeCheckboxGroup,
-      name,
-      defaultValue,
-      value: valueProp,
-      required = false,
-      disabled = false,
-      orientation,
-      dir,
-      loop = true,
-      onValueChange,
-      ...props
-    }: ScopedProps<CheckboxGroupProps>,
-    forwardedRef,
-  ) => {
-    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeCheckboxGroup);
-    const direction = useDirection(dir);
-    const [value = [], setValue] = useControllableState({
-      prop: valueProp,
-      defaultProp: defaultValue,
-      onChange: onValueChange,
-    });
-
-    const handleItemCheck = React.useCallback(
-      (itemValue: string) => {
-        setValue((prevValue = []) => [...prevValue, itemValue]);
-      },
-      [setValue],
-    );
-
-    const handleItemUncheck = React.useCallback(
-      (itemValue: string) => {
-        setValue((prevValue = []) => prevValue.filter((val) => val !== itemValue));
-      },
-      [setValue],
-    );
-
-    return (
-      <CheckboxGroupProvider
-        disabled={disabled}
-        name={name}
-        required={required}
-        scope={__scopeCheckboxGroup}
-        value={value}
-        onItemCheck={handleItemCheck}
-        onItemUncheck={handleItemUncheck}
-      >
-        <RovingFocusGroup.Root asChild {...rovingFocusGroupScope} dir={direction} loop={loop} orientation={orientation}>
-          {/* eslint-disable-next-line react/jsx-pascal-case -- radix-ui */}
-          <Primitive.div
-            ref={forwardedRef}
-            data-disabled={disabled ? '' : undefined}
-            dir={direction}
-            role="group"
-            {...props}
-          />
-        </RovingFocusGroup.Root>
-      </CheckboxGroupProvider>
-    );
-  },
-);
-
-CheckboxGroup.displayName = CHECKBOX_GROUP_NAME;
-
-/* -------------------------------------------------------------------------------------------------
- * Component: CheckboxGroupItem
- * -----------------------------------------------------------------------------------------------*/
-
-const ITEM_NAME = `${CHECKBOX_GROUP_NAME}Item`;
-
-type CheckboxGroupItemElement = React.ElementRef<typeof CheckboxPrimitive.Root>;
-
-interface CheckboxGroupItemProps
-  extends Omit<
-    React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>,
-    'checked' | 'defaultChecked' | 'onCheckedChange' | 'name'
-  > {
-  value: string;
-}
-
-const CheckboxGroupItem = React.forwardRef<CheckboxGroupItemElement, CheckboxGroupItemProps>(
-  ({ __scopeCheckboxGroup, disabled, ...props }: ScopedProps<CheckboxGroupItemProps>, forwardedRef) => {
-    const context = useCheckboxGroupContext(ITEM_NAME, __scopeCheckboxGroup);
-    const isDisabled = context.disabled || disabled;
-    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeCheckboxGroup);
-    const checkboxScope = useCheckboxScope(__scopeCheckboxGroup);
-    const checked = context.value?.includes(props.value);
-
-    return (
-      <RovingFocusGroup.Item asChild {...rovingFocusGroupScope} active={checked} focusable={!isDisabled}>
-        <CheckboxPrimitive.Root
-          ref={forwardedRef}
-          checked={checked}
-          disabled={isDisabled}
-          name={context.name}
-          required={context.required}
-          {...checkboxScope}
-          {...props}
-          onCheckedChange={(checkedState) => {
-            if (checkedState) {
-              context.onItemCheck(props.value);
-            } else {
-              context.onItemUncheck(props.value);
-            }
-          }}
-        />
-      </RovingFocusGroup.Item>
-    );
-  },
-);
-
-CheckboxGroupItem.displayName = ITEM_NAME;
-
-/* -------------------------------------------------------------------------------------------------
- * Component: CheckboxGroupIndicator
- * -----------------------------------------------------------------------------------------------*/
-
-const INDICATOR_NAME = `${CHECKBOX_GROUP_NAME}Indicator`;
-
-type CheckboxGroupIndicatorElement = React.ElementRef<typeof CheckboxPrimitive.Indicator>;
-type CheckboxGroupIndicatorProps = React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Indicator>;
-
-const CheckboxGroupIndicator = React.forwardRef<CheckboxGroupIndicatorElement, CheckboxGroupIndicatorProps>(
-  ({ __scopeCheckboxGroup, ...props }: ScopedProps<CheckboxGroupIndicatorProps>, forwardedRef) => {
-    const checkboxScope = useCheckboxScope(__scopeCheckboxGroup);
-
-    return <CheckboxPrimitive.Indicator ref={forwardedRef} {...checkboxScope} {...props} />;
-  },
-);
-
-CheckboxGroupIndicator.displayName = INDICATOR_NAME;
-
-/* -----------------------------------------------------------------------------
- * Exports
- * -------------------------------------------------------------------------- */
-
-const Root = CheckboxGroup;
-const Item = CheckboxGroupItem;
-const Indicator = CheckboxGroupIndicator;
-
-export {
-  createCheckboxGroupScope,
-  CheckboxGroup,
-  CheckboxGroupItem,
-  CheckboxGroupIndicator,
-  Root,
-  Item,
-  Indicator,
-  type CheckboxGroupProps,
-  type CheckboxGroupItemProps,
-  type CheckboxGroupIndicatorProps,
-};

package/src/react/checkbox-group.tsx

@@ -1,55 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { CheckIcon } from '@radix-ui/react-icons';
-import { cn } from '../lib/utils';
-import * as CheckboxGroupPrimitive from './checkbox-group.primitive';
-
-/* -----------------------------------------------------------------------------
- * Component: CheckboxGroup
- * -------------------------------------------------------------------------- */
-
-type CheckboxGroupElement = React.ElementRef<typeof CheckboxGroupPrimitive.Root>;
-type CheckboxGroupProps = React.ComponentPropsWithoutRef<typeof CheckboxGroupPrimitive.Root>;
-
-const CheckboxGroup = React.forwardRef<CheckboxGroupElement, CheckboxGroupProps>(
-  ({ className, ...props }, forwardedRef) => {
-    return <CheckboxGroupPrimitive.Root ref={forwardedRef} className={cn('grid gap-2', className)} {...props} />;
-  },
-);
-
-CheckboxGroup.displayName = 'CheckboxGroup';
-
-/* -----------------------------------------------------------------------------
- * Component: CheckboxGroupItem
- * -------------------------------------------------------------------------- */
-
-type CheckboxGroupItemElement = React.ElementRef<typeof CheckboxGroupPrimitive.Item>;
-type CheckboxGroupItemProps = React.ComponentPropsWithoutRef<typeof CheckboxGroupPrimitive.Item>;
-
-const CheckboxGroupItem = React.forwardRef<CheckboxGroupItemElement, CheckboxGroupItemProps>(
-  ({ className, ...props }, forwardedRef) => {
-    return (
-      <CheckboxGroupPrimitive.Item
-        ref={forwardedRef}
-        className={cn(
-          'border-input hover:border-primary aria-checked:border-primary aria-checked:bg-primary aria-checked:text-primary-foreground peer flex size-4 shrink-0 rounded-sm border shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 disabled:pointer-events-none disabled:opacity-50',
-          className,
-        )}
-        {...props}
-      >
-        <CheckboxGroupPrimitive.CheckboxGroupIndicator className="flex size-full items-center justify-center text-current">
-          <CheckIcon className="size-3.5" />
-        </CheckboxGroupPrimitive.CheckboxGroupIndicator>
-      </CheckboxGroupPrimitive.Item>
-    );
-  },
-);
-
-CheckboxGroupItem.displayName = 'CheckboxGroupItem';
-
-/* -----------------------------------------------------------------------------
- * Exports
- * -------------------------------------------------------------------------- */
-
-export { CheckboxGroup, CheckboxGroupItem, type CheckboxGroupProps, type CheckboxGroupItemProps };

package/src/react/checkbox.tsx

@@ -1,36 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
-import { CheckIcon } from '@radix-ui/react-icons';
-import { cn } from '../lib/utils';
-
-/* -----------------------------------------------------------------------------
- * Component: Checkbox
- * -------------------------------------------------------------------------- */
-
-type CheckboxElement = React.ElementRef<typeof CheckboxPrimitive.Root>;
-type CheckboxProps = React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>;
-
-const Checkbox = React.forwardRef<CheckboxElement, CheckboxProps>(({ className, ...props }, forwardedRef) => (
-  <CheckboxPrimitive.Root
-    ref={forwardedRef}
-    className={cn(
-      'border-input hover:border-primary aria-checked:border-primary aria-checked:bg-primary aria-checked:text-primary-foreground peer flex size-4 shrink-0 rounded-sm border shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 disabled:cursor-default disabled:opacity-50',
-      className,
-    )}
-    {...props}
-  >
-    <CheckboxPrimitive.Indicator className="flex size-full items-center justify-center text-current">
-      <CheckIcon className="size-3.5" />
-    </CheckboxPrimitive.Indicator>
-  </CheckboxPrimitive.Root>
-));
-
-Checkbox.displayName = CheckboxPrimitive.Root.displayName;
-
-/* -----------------------------------------------------------------------------
- * Exports
- * -------------------------------------------------------------------------- */
-
-export { Checkbox, type CheckboxProps };

package/src/react/code.tsx

@@ -1,26 +0,0 @@
-import * as React from 'react';
-import { Slot } from '@radix-ui/react-slot';
-
-/* -----------------------------------------------------------------------------
- * Component: Code
- * -------------------------------------------------------------------------- */
-
-type CodeElement = HTMLElement;
-
-interface CodeProps extends React.HTMLAttributes<HTMLElement> {
-  asChild?: boolean;
-}
-
-const Code = React.forwardRef<CodeElement, CodeProps>(({ asChild, ...props }, forwardedRef) => {
-  const Component = asChild ? Slot : 'code';
-
-  return <Component ref={forwardedRef} {...props} />;
-});
-
-Code.displayName = 'Code';
-
-/* -----------------------------------------------------------------------------
- * Exports
- * -------------------------------------------------------------------------- */
-
-export { Code, type CodeProps };