@kuzenbo/core 0.0.1 → 0.0.3

package/dist/ui/radio-group.d.ts

@@ -0,0 +1,102 @@
+import { t as UISize } from "../size-system-wzOLSuax.js";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as tailwind_variants0 from "tailwind-variants";
+import { VariantProps } from "tailwind-variants";
+import { RadioGroup as RadioGroup$1 } from "@base-ui/react/radio-group";
+import { Radio } from "@base-ui/react/radio";
+
+//#region src/ui/radio-group/radio-group-indicator.d.ts
+declare const radioGroupIndicatorVariants: tailwind_variants0.TVReturnType<{
+  size: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+}, undefined, "flex items-center justify-center text-primary group-aria-invalid/radio-group-item:text-danger", {
+  size: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+}, undefined, tailwind_variants0.TVReturnType<{
+  size: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+}, undefined, "flex items-center justify-center text-primary group-aria-invalid/radio-group-item:text-danger", unknown, unknown, undefined>>;
+type RadioGroupIndicatorVariantProps = Omit<VariantProps<typeof radioGroupIndicatorVariants>, "size"> & {
+  size?: UISize;
+};
+type RadioGroupIndicatorProps = Radio.Indicator.Props & RadioGroupIndicatorVariantProps;
+declare const RadioGroupIndicator: ({
+  className,
+  size: providedSize,
+  ...props
+}: RadioGroupIndicatorProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/ui/radio-group/radio-group-item.d.ts
+declare const radioGroupItemVariants: tailwind_variants0.TVReturnType<{
+  size: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+}, undefined, "group/radio-group-item peer relative flex shrink-0 cursor-pointer rounded-full border border-input text-primary-foreground shadow-xs outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-danger-foreground aria-invalid:ring-[3px] aria-invalid:ring-danger-foreground/20 dark:bg-input/30 dark:aria-invalid:border-danger-foreground/50 dark:aria-invalid:ring-danger-foreground/40", {
+  size: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+}, undefined, tailwind_variants0.TVReturnType<{
+  size: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+}, undefined, "group/radio-group-item peer relative flex shrink-0 cursor-pointer rounded-full border border-input text-primary-foreground shadow-xs outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-danger-foreground aria-invalid:ring-[3px] aria-invalid:ring-danger-foreground/20 dark:bg-input/30 dark:aria-invalid:border-danger-foreground/50 dark:aria-invalid:ring-danger-foreground/40", unknown, unknown, undefined>>;
+type RadioGroupItemVariantProps = Omit<VariantProps<typeof radioGroupItemVariants>, "size"> & {
+  size?: UISize;
+};
+type RadioGroupItemProps = Radio.Root.Props & RadioGroupItemVariantProps;
+declare const RadioGroupItem: ({
+  className,
+  children,
+  size: providedSize,
+  ...props
+}: RadioGroupItemProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/ui/radio-group/radio-group.d.ts
+type RadioGroupProps<Value = unknown> = RadioGroup$1.Props<Value>;
+declare const RadioGroup: {
+  ({
+    className,
+    ...props
+  }: RadioGroupProps): react_jsx_runtime0.JSX.Element;
+  Indicator: ({
+    className,
+    size: providedSize,
+    ...props
+  }: RadioGroupIndicatorProps) => react_jsx_runtime0.JSX.Element;
+  Item: ({
+    className,
+    children,
+    size: providedSize,
+    ...props
+  }: RadioGroupItemProps) => react_jsx_runtime0.JSX.Element;
+};
+//#endregion
+export { RadioGroup, RadioGroupIndicator, type RadioGroupIndicatorProps, RadioGroupItem, type RadioGroupItemProps, RadioGroupProps };
+//# sourceMappingURL=radio-group.d.ts.map

package/dist/ui/radio-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.d.ts","names":[],"sources":["../../src/ui/radio-group/radio-group-indicator.tsx","../../src/ui/radio-group/radio-group-item.tsx","../../src/ui/radio-group/radio-group.tsx"],"mappings":";;;;;;;;cAQM,2BAAA,EAcJ,kBAAA,CAd+B,YAAA;;;;;;;;;;;;;;;;cAc/B,kBAAA,CAAA,YAAA;;;;;;;;;KAEG,+BAAA,GAAkC,IAAA,CACrC,YAAA,QAAoB,2BAAA;EAGpB,IAAA,GAAO,MAAA;AAAA;AAAA,KAGG,wBAAA,GAA2B,KAAA,CAAe,SAAA,CAAU,KAAA,GAC9D,+BAAA;AAAA,cAEI,mBAAA;EAAuB,SAAA;EAAA,IAAA,EAAA,YAAA;EAAA,GAAA;AAAA,GAI1B,wBAAA,KAAwB,kBAAA,CAAA,GAAA,CAAA,OAAA;;;cC3BrB,sBAAA,EAcJ,kBAAA,CAd0B,YAAA;;;;;;;;;;;;;;;;cAc1B,kBAAA,CAAA,YAAA;;;;;;;;;KAEG,0BAAA,GAA6B,IAAA,CAChC,YAAA,QAAoB,sBAAA;EAGpB,IAAA,GAAO,MAAA;AAAA;AAAA,KAGG,mBAAA,GAAsB,KAAA,CAAe,IAAA,CAAK,KAAA,GACpD,0BAAA;AAAA,cAEI,cAAA;EAAkB,SAAA;EAAA,QAAA;EAAA,IAAA,EAAA,YAAA;EAAA,GAAA;AAAA,GAKrB,mBAAA,KAAmB,kBAAA,CAAA,GAAA,CAAA,OAAA;;;KCpCV,eAAA,oBAAmC,YAAA,CAAoB,KAAA,CAAM,KAAA;AAAA,cAEnE,UAAA;EAAA;;;KAAuC,eAAA,GAAe,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/ui/radio-group.js

@@ -0,0 +1,76 @@
+import { a as useComponentSize } from "../size-provider-18EvJgDT.js";
+import { t as mergeBaseUIClassName } from "../merge-base-ui-class-name-HKsgjcXj.js";
+import { jsx } from "react/jsx-runtime";
+import { tv } from "tailwind-variants";
+import { CircleIcon } from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
+import { RadioGroup as RadioGroup$1 } from "@base-ui/react/radio-group";
+import { Radio } from "@base-ui/react/radio";
+
+//#region src/ui/radio-group/radio-group-indicator.tsx
+const radioGroupIndicatorVariants = tv({
+	base: "flex items-center justify-center text-primary group-aria-invalid/radio-group-item:text-danger",
+	variants: { size: {
+		xs: "size-3",
+		sm: "size-3.5",
+		md: "size-4",
+		lg: "size-[18px]",
+		xl: "size-5"
+	} },
+	defaultVariants: { size: "md" }
+});
+const RadioGroupIndicator = ({ className, size: providedSize, ...props }) => {
+	const size = useComponentSize(providedSize);
+	return /* @__PURE__ */ jsx(Radio.Indicator, {
+		className: mergeBaseUIClassName(radioGroupIndicatorVariants({ size }), className),
+		"data-size": size,
+		"data-slot": "radio-group-indicator",
+		...props
+	});
+};
+
+//#endregion
+//#region src/ui/radio-group/radio-group-item.tsx
+const radioGroupItemVariants = tv({
+	base: "group/radio-group-item peer relative flex shrink-0 cursor-pointer rounded-full border border-input text-primary-foreground shadow-xs outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-danger-foreground aria-invalid:ring-[3px] aria-invalid:ring-danger-foreground/20 dark:bg-input/30 dark:aria-invalid:border-danger-foreground/50 dark:aria-invalid:ring-danger-foreground/40",
+	variants: { size: {
+		xs: "aspect-square size-3 after:absolute after:-inset-1.5",
+		sm: "aspect-square size-3.5 after:absolute after:-inset-2",
+		md: "aspect-square size-4 after:absolute after:-inset-2.5",
+		lg: "aspect-square size-[18px] after:absolute after:-inset-3",
+		xl: "aspect-square size-5 after:absolute after:-inset-3.5"
+	} },
+	defaultVariants: { size: "md" }
+});
+const RadioGroupItem = ({ className, children, size: providedSize, ...props }) => {
+	const size = useComponentSize(providedSize);
+	return /* @__PURE__ */ jsx(Radio.Root, {
+		className: mergeBaseUIClassName(radioGroupItemVariants({ size }), className),
+		"data-size": size,
+		"data-slot": "radio-group-item",
+		...props,
+		children: children ?? /* @__PURE__ */ jsx(RadioGroupIndicator, {
+			size,
+			children: /* @__PURE__ */ jsx(HugeiconsIcon, {
+				className: "absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 fill-current data-[size=xs]:size-1.5 data-[size=sm]:size-1.5 data-[size=md]:size-2 data-[size=lg]:size-2 data-[size=xl]:size-2.5",
+				"data-size": size,
+				icon: CircleIcon,
+				strokeWidth: 2
+			})
+		})
+	});
+};
+
+//#endregion
+//#region src/ui/radio-group/radio-group.tsx
+const RadioGroup = ({ className, ...props }) => /* @__PURE__ */ jsx(RadioGroup$1, {
+	className: mergeBaseUIClassName("grid w-full gap-2", className),
+	"data-slot": "radio-group",
+	...props
+});
+RadioGroup.Indicator = RadioGroupIndicator;
+RadioGroup.Item = RadioGroupItem;
+
+//#endregion
+export { RadioGroup, RadioGroupIndicator, RadioGroupItem };
+//# sourceMappingURL=radio-group.js.map

package/dist/ui/radio-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.js","names":["RadioPrimitive","RadioPrimitive","RadioGroupPrimitive"],"sources":["../../src/ui/radio-group/radio-group-indicator.tsx","../../src/ui/radio-group/radio-group-item.tsx","../../src/ui/radio-group/radio-group.tsx"],"sourcesContent":["import { Radio as RadioPrimitive } from \"@base-ui/react/radio\";\nimport { tv, type VariantProps } from \"tailwind-variants\";\n\nimport type { UISize } from \"../shared/size/size-system\";\n\nimport { mergeBaseUIClassName } from \"../../utils/merge-base-ui-class-name\";\nimport { useComponentSize } from \"../shared/size/size-provider\";\n\nconst radioGroupIndicatorVariants = tv({\n  base: \"flex items-center justify-center text-primary group-aria-invalid/radio-group-item:text-danger\",\n  variants: {\n    size: {\n      xs: \"size-3\",\n      sm: \"size-3.5\",\n      md: \"size-4\",\n      lg: \"size-[18px]\",\n      xl: \"size-5\",\n    },\n  },\n  defaultVariants: {\n    size: \"md\",\n  },\n});\n\ntype RadioGroupIndicatorVariantProps = Omit<\n  VariantProps<typeof radioGroupIndicatorVariants>,\n  \"size\"\n> & {\n  size?: UISize;\n};\n\nexport type RadioGroupIndicatorProps = RadioPrimitive.Indicator.Props &\n  RadioGroupIndicatorVariantProps;\n\nconst RadioGroupIndicator = ({\n  className,\n  size: providedSize,\n  ...props\n}: RadioGroupIndicatorProps) => {\n  const size = useComponentSize(providedSize);\n\n  return (\n    <RadioPrimitive.Indicator\n      className={mergeBaseUIClassName<RadioPrimitive.Indicator.State>(\n        radioGroupIndicatorVariants({ size }),\n        className\n      )}\n      data-size={size}\n      data-slot=\"radio-group-indicator\"\n      {...props}\n    />\n  );\n};\n\nexport { RadioGroupIndicator };\n","import { Radio as RadioPrimitive } from \"@base-ui/react/radio\";\nimport { CircleIcon } from \"@hugeicons/core-free-icons\";\nimport { HugeiconsIcon } from \"@hugeicons/react\";\nimport { tv, type VariantProps } from \"tailwind-variants\";\n\nimport type { UISize } from \"../shared/size/size-system\";\n\nimport { mergeBaseUIClassName } from \"../../utils/merge-base-ui-class-name\";\nimport { useComponentSize } from \"../shared/size/size-provider\";\nimport { RadioGroupIndicator } from \"./radio-group-indicator\";\n\nconst radioGroupItemVariants = tv({\n  base: \"group/radio-group-item peer relative flex shrink-0 cursor-pointer rounded-full border border-input text-primary-foreground shadow-xs outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-danger-foreground aria-invalid:ring-[3px] aria-invalid:ring-danger-foreground/20 dark:bg-input/30 dark:aria-invalid:border-danger-foreground/50 dark:aria-invalid:ring-danger-foreground/40\",\n  variants: {\n    size: {\n      xs: \"aspect-square size-3 after:absolute after:-inset-1.5\",\n      sm: \"aspect-square size-3.5 after:absolute after:-inset-2\",\n      md: \"aspect-square size-4 after:absolute after:-inset-2.5\",\n      lg: \"aspect-square size-[18px] after:absolute after:-inset-3\",\n      xl: \"aspect-square size-5 after:absolute after:-inset-3.5\",\n    },\n  },\n  defaultVariants: {\n    size: \"md\",\n  },\n});\n\ntype RadioGroupItemVariantProps = Omit<\n  VariantProps<typeof radioGroupItemVariants>,\n  \"size\"\n> & {\n  size?: UISize;\n};\n\nexport type RadioGroupItemProps = RadioPrimitive.Root.Props &\n  RadioGroupItemVariantProps;\n\nconst RadioGroupItem = ({\n  className,\n  children,\n  size: providedSize,\n  ...props\n}: RadioGroupItemProps) => {\n  const size = useComponentSize(providedSize);\n\n  return (\n    <RadioPrimitive.Root\n      className={mergeBaseUIClassName<RadioPrimitive.Root.State>(\n        radioGroupItemVariants({ size }),\n        className\n      )}\n      data-size={size}\n      data-slot=\"radio-group-item\"\n      {...props}\n    >\n      {children ?? (\n        <RadioGroupIndicator size={size}>\n          <HugeiconsIcon\n            className=\"absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 fill-current data-[size=xs]:size-1.5 data-[size=sm]:size-1.5 data-[size=md]:size-2 data-[size=lg]:size-2 data-[size=xl]:size-2.5\"\n            data-size={size}\n            icon={CircleIcon}\n            strokeWidth={2}\n          />\n        </RadioGroupIndicator>\n      )}\n    </RadioPrimitive.Root>\n  );\n};\n\nexport { RadioGroupItem };\n","import { RadioGroup as RadioGroupPrimitive } from \"@base-ui/react/radio-group\";\n\nimport { mergeBaseUIClassName } from \"../../utils/merge-base-ui-class-name\";\nimport { RadioGroupIndicator } from \"./radio-group-indicator\";\nimport { RadioGroupItem } from \"./radio-group-item\";\n\nexport type RadioGroupProps<Value = unknown> = RadioGroupPrimitive.Props<Value>;\n\nconst RadioGroup = ({ className, ...props }: RadioGroupProps) => (\n  <RadioGroupPrimitive\n    className={mergeBaseUIClassName<RadioGroupPrimitive.State>(\n      \"grid w-full gap-2\",\n      className\n    )}\n    data-slot=\"radio-group\"\n    {...props}\n  />\n);\n\nRadioGroup.Indicator = RadioGroupIndicator;\nRadioGroup.Item = RadioGroupItem;\n\nexport type { RadioGroupIndicatorProps } from \"./radio-group-indicator\";\nexport type { RadioGroupItemProps } from \"./radio-group-item\";\n\nexport { RadioGroup, RadioGroupIndicator, RadioGroupItem };\n"],"mappings":";;;;;;;;;;AAQA,MAAM,8BAA8B,GAAG;CACrC,MAAM;CACN,UAAU,EACR,MAAM;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACL,EACF;CACD,iBAAiB,EACf,MAAM,MACP;CACF,CAAC;AAYF,MAAM,uBAAuB,EAC3B,WACA,MAAM,cACN,GAAG,YAC2B;CAC9B,MAAM,OAAO,iBAAiB,aAAa;AAE3C,QACE,oBAACA,MAAe;EACd,WAAW,qBACT,4BAA4B,EAAE,MAAM,CAAC,EACrC,UACD;EACD,aAAW;EACX,aAAU;EACV,GAAI;GACJ;;;;;ACvCN,MAAM,yBAAyB,GAAG;CAChC,MAAM;CACN,UAAU,EACR,MAAM;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACL,EACF;CACD,iBAAiB,EACf,MAAM,MACP;CACF,CAAC;AAYF,MAAM,kBAAkB,EACtB,WACA,UACA,MAAM,cACN,GAAG,YACsB;CACzB,MAAM,OAAO,iBAAiB,aAAa;AAE3C,QACE,oBAACC,MAAe;EACd,WAAW,qBACT,uBAAuB,EAAE,MAAM,CAAC,EAChC,UACD;EACD,aAAW;EACX,aAAU;EACV,GAAI;YAEH,YACC,oBAAC;GAA0B;aACzB,oBAAC;IACC,WAAU;IACV,aAAW;IACX,MAAM;IACN,aAAa;KACb;IACkB;GAEJ;;;;;ACzD1B,MAAM,cAAc,EAAE,WAAW,GAAG,YAClC,oBAACC;CACC,WAAW,qBACT,qBACA,UACD;CACD,aAAU;CACV,GAAI;EACJ;AAGJ,WAAW,YAAY;AACvB,WAAW,OAAO"}

package/dist/ui/range-slider/range-slider-types.d.ts

@@ -0,0 +1,5 @@
+//#region src/ui/range-slider/range-slider-types.d.ts
+type RangeSliderValue = [number, number];
+//#endregion
+export { RangeSliderValue };
+//# sourceMappingURL=range-slider-types.d.ts.map

package/dist/ui/range-slider/range-slider-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-slider-types.d.ts","names":[],"sources":["../../../src/ui/range-slider/range-slider-types.ts"],"mappings":";KAAY,gBAAA"}

package/dist/ui/range-slider.d.ts

@@ -0,0 +1,57 @@
+import { RangeSliderValue } from "./range-slider/range-slider-types.js";
+import { _ as SliderLabel, a as SliderThumbLabel, b as SliderLabelTransitionProps, c as SliderThumbProps, d as SliderMark$1, h as SliderControl, l as SliderMarks, p as SliderIndicator, r as SliderTrack, s as SliderThumb, t as SliderValue, v as SliderMark, w as SliderSize, x as SliderRadius } from "../slider-value-Db8SCu0c.js";
+import { ComponentPropsWithoutRef, ReactNode } from "react";
+import { Slider } from "@base-ui/react/slider";
+
+//#region src/ui/range-slider/range-slider.d.ts
+type RangeSliderRootProps = Omit<Slider.Root.Props<number[]>, "defaultValue" | "max" | "min" | "minStepsBetweenValues" | "name" | "onChange" | "onValueChange" | "onValueCommitted" | "thumbAlignment" | "thumbCollisionBehavior" | "value">;
+interface RangeSliderProps extends RangeSliderRootProps {
+  color?: string;
+  defaultValue?: RangeSliderValue;
+  domain?: [number, number];
+  hiddenInputProps?: Omit<ComponentPropsWithoutRef<"input">, "name" | "type" | "value">;
+  inverted?: boolean;
+  label?: SliderLabel;
+  labelAlwaysOn?: boolean;
+  labelTransitionProps?: SliderLabelTransitionProps;
+  marks?: readonly SliderMark[];
+  max?: number;
+  maxRange?: number;
+  min?: number;
+  minRange?: number;
+  name?: string;
+  onChange?: ((value: RangeSliderValue) => void) | undefined;
+  onChangeEnd?: ((value: RangeSliderValue) => void) | undefined;
+  precision?: number;
+  pushOnOverlap?: boolean;
+  radius?: SliderRadius;
+  restrictToMarks?: boolean;
+  scale?: ((value: number) => number) | undefined;
+  size?: SliderSize;
+  showLabelOnHover?: boolean;
+  step?: number;
+  thumbChildren?: ReactNode | [ReactNode, ReactNode];
+  thumbFromLabel?: string;
+  thumbLabelOffset?: number | string;
+  thumbLabelOffsetVertical?: number | string;
+  thumbProps?: ((index: 0 | 1) => Omit<SliderThumbProps, "aria-label" | "children" | "index">) | undefined;
+  thumbSize?: number | string;
+  thumbToLabel?: string;
+  trackSize?: number | string;
+  markSize?: number | string;
+  value?: RangeSliderValue;
+}
+type RangeSliderComponent = ((props: RangeSliderProps) => ReactNode) & {
+  Control: typeof SliderControl;
+  Indicator: typeof SliderIndicator;
+  Mark: typeof SliderMark$1;
+  Marks: typeof SliderMarks;
+  Thumb: typeof SliderThumb;
+  ThumbLabel: typeof SliderThumbLabel;
+  Track: typeof SliderTrack;
+  Value: typeof SliderValue;
+};
+declare const RangeSlider: RangeSliderComponent;
+//#endregion
+export { RangeSlider, RangeSliderProps };
+//# sourceMappingURL=range-slider.d.ts.map

package/dist/ui/range-slider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-slider.d.ts","names":[],"sources":["../../src/ui/range-slider/range-slider.tsx"],"mappings":";;;;;;KAyCK,oBAAA,GAAuB,IAAA,CAC1B,MAAA,CAAgB,IAAA,CAAK,KAAA;AAAA,UAcN,gBAAA,SAAyB,oBAAA;EACxC,KAAA;EACA,YAAA,GAAe,gBAAA;EACf,MAAA;EACA,gBAAA,GAAmB,IAAA,CACjB,wBAAA;EAGF,QAAA;EACA,KAAA,GAAQ,WAAA;EACR,aAAA;EACA,oBAAA,GAAuB,0BAAA;EACvB,KAAA,YAAiB,UAAA;EACjB,GAAA;EACA,QAAA;EACA,GAAA;EACA,QAAA;EACA,IAAA;EACA,QAAA,KAAa,KAAA,EAAO,gBAAA;EACpB,WAAA,KAAgB,KAAA,EAAO,gBAAA;EACvB,SAAA;EACA,aAAA;EACA,MAAA,GAAS,YAAA;EACT,eAAA;EACA,KAAA,KAAU,KAAA;EACV,IAAA,GAAO,UAAA;EACP,gBAAA;EACA,IAAA;EACA,aAAA,GAAgB,SAAA,IAAa,SAAA,EAAW,SAAA;EACxC,cAAA;EACA,gBAAA;EACA,wBAAA;EACA,UAAA,KAEM,KAAA,YACG,IAAA,CAAK,gBAAA;EAEd,SAAA;EACA,YAAA;EACA,SAAA;EACA,QAAA;EACA,KAAA,GAAQ,gBAAA;AAAA;AAAA,KAGL,oBAAA,KAAyB,KAAA,EAAO,gBAAA,KAAqB,SAAA;EACxD,OAAA,SAAgB,aAAA;EAChB,SAAA,SAAkB,eAAA;EAClB,IAAA,SAAa,YAAA;EACb,KAAA,SAAc,WAAA;EACd,KAAA,SAAc,WAAA;EACd,UAAA,SAAmB,gBAAA;EACnB,KAAA,SAAc,WAAA;EACd,KAAA,SAAc,WAAA;AAAA;AAAA,cAGV,WAAA,EAgLA,oBAAA"}

package/dist/ui/range-slider.js

@@ -0,0 +1,338 @@
+"use client";
+
+import { _ as getNextMarkValue, a as SliderValue, b as isKeyboardLikeReason, c as SliderThumb, d as SliderIndicator, f as SliderControl, g as getNearestMarkValue, h as getLastMarkValue, i as resolveSliderBounds, l as SliderMarks, m as getFirstMarkValue, n as resolveSliderRootClassName, o as SliderTrack, p as clampNumber, r as resolveSliderLabel, s as SliderThumbLabel, t as mergeSliderRootStyle, u as SliderMark, v as getPreviousMarkValue, x as toFloatingValue, y as getSortedSelectableMarks } from "../slider-root-presentation-ChJHPMIV.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Slider } from "@base-ui/react/slider";
+
+//#region src/ui/range-slider/range-slider-helpers.ts
+const MIN_STEP_TOLERANCE_MULTIPLIER = 10;
+const getMinStepsBetweenValues = ({ minRange, restrictToMarks, step }) => {
+	if (restrictToMarks || step <= 0 || !Number.isFinite(minRange)) return;
+	const steps = minRange / step;
+	if (!Number.isFinite(steps) || steps < 0) return;
+	const roundedSteps = Math.round(steps);
+	return Math.abs(steps - roundedSteps) < Number.EPSILON * MIN_STEP_TOLERANCE_MULTIPLIER ? roundedSteps : void 0;
+};
+const getThumbChildrenByIndex = (thumbChildren, index) => {
+	if (!Array.isArray(thumbChildren)) return thumbChildren;
+	return thumbChildren[index];
+};
+
+//#endregion
+//#region src/ui/range-slider/math/normalize-range-slider-value.ts
+const getResolvedActiveThumbIndex = (current, raw, activeThumbIndex) => {
+	if (activeThumbIndex === 0 || activeThumbIndex === 1) return activeThumbIndex;
+	const currentFrom = current[0] ?? 0;
+	const currentTo = current[1] ?? 0;
+	const rawFrom = raw[0] ?? currentFrom;
+	const rawTo = raw[1] ?? currentTo;
+	return Math.abs(rawFrom - currentFrom) >= Math.abs(rawTo - currentTo) ? 0 : 1;
+};
+const normalizeRangeSliderValue = ({ activeThumbIndex, current, domainMax, domainMin, marks, max, maxRange, min, minRange, precision, pushOnOverlap, raw, reason, restrictToMarks }) => {
+	const currentFrom = clampNumber(current[0] ?? min, min, max);
+	const currentTo = clampNumber(current[1] ?? max, min, max);
+	const currentValues = [currentFrom, currentTo];
+	const clampedRawFrom = clampNumber(raw[0] ?? currentFrom, domainMin, domainMax);
+	const clampedRawTo = clampNumber(raw[1] ?? currentTo, domainMin, domainMax);
+	const resolvedActiveIndex = getResolvedActiveThumbIndex([currentFrom, currentTo], [clampedRawFrom, clampedRawTo], activeThumbIndex);
+	const clone = [clampNumber(clampedRawFrom, min, max), clampNumber(clampedRawTo, min, max)];
+	if (restrictToMarks) {
+		const selectableMarks = getSortedSelectableMarks(marks, min, max);
+		if (selectableMarks.length) {
+			const firstMarkValue = getFirstMarkValue(selectableMarks, min);
+			const lastMarkValue = getLastMarkValue(selectableMarks, max);
+			const index = resolvedActiveIndex;
+			const otherIndex = index === 0 ? 1 : 0;
+			const currentAtIndex = currentValues[index];
+			const rawAtIndex = index === 0 ? clampedRawFrom : clampedRawTo;
+			if (isKeyboardLikeReason(reason)) if (rawAtIndex <= min) clone[index] = firstMarkValue;
+			else if (rawAtIndex >= max) clone[index] = lastMarkValue;
+			else if (rawAtIndex > currentAtIndex) clone[index] = getNextMarkValue(currentAtIndex, selectableMarks);
+			else if (rawAtIndex < currentAtIndex) clone[index] = getPreviousMarkValue(currentAtIndex, selectableMarks);
+			else clone[index] = getNearestMarkValue(rawAtIndex, selectableMarks);
+			else clone[index] = getNearestMarkValue(rawAtIndex, selectableMarks);
+			if (clone[index] === lastMarkValue && clone[otherIndex] === lastMarkValue) clone[index] = currentAtIndex;
+			else if (clone[index] === firstMarkValue && clone[otherIndex] === firstMarkValue) clone[index] = currentAtIndex;
+			else if (clone[index] === clone[otherIndex]) if (currentAtIndex > clone[otherIndex]) clone[otherIndex] = getPreviousMarkValue(clone[index], selectableMarks);
+			else clone[otherIndex] = getNextMarkValue(clone[index], selectableMarks);
+		}
+	} else {
+		const safeMinRange = Number.isFinite(minRange) ? Math.max(minRange, 0) : 0;
+		const safeMaxRange = Number.isFinite(maxRange) ? Math.max(maxRange, safeMinRange) : Number.POSITIVE_INFINITY;
+		if (resolvedActiveIndex === 0) {
+			const [clamped] = clone;
+			if (clamped > clone[1] - (safeMinRange - 1e-9)) if (pushOnOverlap) clone[1] = Math.min(clamped + safeMinRange, max);
+			else clone[0] = currentFrom;
+			if (clamped > clone[1] - (safeMinRange - 1e-9)) if (pushOnOverlap) clone[0] = clone[1] - safeMinRange;
+			else clone[0] = currentFrom;
+			if (clone[1] - clamped > safeMaxRange) if (pushOnOverlap) clone[1] = clamped + safeMaxRange;
+			else clone[0] = currentFrom;
+		}
+		if (resolvedActiveIndex === 1) {
+			const [, clamped] = clone;
+			if (clamped < clone[0] + safeMinRange) if (pushOnOverlap) clone[0] = Math.max(clamped - safeMinRange, min);
+			else clone[1] = currentTo;
+			if (clamped < clone[0] + safeMinRange) if (pushOnOverlap) clone[1] = clone[0] + safeMinRange;
+			else clone[1] = currentTo;
+			if (clamped - clone[0] > safeMaxRange) if (pushOnOverlap) clone[0] = clamped - safeMaxRange;
+			else clone[1] = currentTo;
+		}
+	}
+	const rounded = [toFloatingValue(clampNumber(clone[0], min, max), precision), toFloatingValue(clampNumber(clone[1], min, max), precision)];
+	if (rounded[0] > rounded[1]) return [rounded[1], rounded[0]];
+	return rounded;
+};
+
+//#endregion
+//#region src/ui/range-slider/use-range-slider-state.ts
+const useRangeSliderState = ({ defaultValue, domainMax, domainMin, marks, max, maxRange, min, minRange, onChange, onChangeEnd, precision, pushOnOverlap, restrictToMarks, value }) => {
+	const [uncontrolledValue, setUncontrolledValue] = useState(useMemo(() => normalizeRangeSliderValue({
+		current: [min, max],
+		domainMax,
+		domainMin,
+		marks,
+		max,
+		maxRange,
+		min,
+		minRange,
+		precision,
+		pushOnOverlap,
+		raw: defaultValue ?? [min, max],
+		restrictToMarks
+	}), [
+		defaultValue,
+		domainMax,
+		domainMin,
+		marks,
+		max,
+		maxRange,
+		min,
+		minRange,
+		precision,
+		pushOnOverlap,
+		restrictToMarks
+	]));
+	const rangeValue = useMemo(() => {
+		if (value === void 0) return;
+		return normalizeRangeSliderValue({
+			current: uncontrolledValue,
+			domainMax,
+			domainMin,
+			marks,
+			max,
+			maxRange,
+			min,
+			minRange,
+			precision,
+			pushOnOverlap,
+			raw: value,
+			restrictToMarks
+		});
+	}, [
+		domainMax,
+		domainMin,
+		marks,
+		max,
+		maxRange,
+		min,
+		minRange,
+		precision,
+		pushOnOverlap,
+		restrictToMarks,
+		uncontrolledValue,
+		value
+	]) ?? uncontrolledValue;
+	const valueRef = useRef(rangeValue);
+	useEffect(() => {
+		valueRef.current = rangeValue;
+	}, [rangeValue]);
+	useEffect(() => {
+		if (value !== void 0) return;
+		setUncontrolledValue((previous) => normalizeRangeSliderValue({
+			current: previous,
+			domainMax,
+			domainMin,
+			marks,
+			max,
+			maxRange,
+			min,
+			minRange,
+			precision,
+			pushOnOverlap,
+			raw: previous,
+			restrictToMarks
+		}));
+	}, [
+		domainMax,
+		domainMin,
+		marks,
+		max,
+		maxRange,
+		min,
+		minRange,
+		precision,
+		pushOnOverlap,
+		restrictToMarks,
+		value
+	]);
+	return {
+		handleValueChange: useCallback((nextValue, eventDetails) => {
+			const rawValues = Array.isArray(nextValue) ? [nextValue[0] ?? valueRef.current[0], nextValue[1] ?? valueRef.current[1]] : [nextValue, valueRef.current[1]];
+			const normalizedValue = normalizeRangeSliderValue({
+				activeThumbIndex: eventDetails.activeThumbIndex,
+				current: valueRef.current,
+				domainMax,
+				domainMin,
+				marks,
+				max,
+				maxRange,
+				min,
+				minRange,
+				precision,
+				pushOnOverlap,
+				raw: rawValues,
+				reason: eventDetails.reason,
+				restrictToMarks
+			});
+			valueRef.current = normalizedValue;
+			if (value === void 0) setUncontrolledValue(normalizedValue);
+			onChange?.(normalizedValue);
+		}, [
+			domainMax,
+			domainMin,
+			marks,
+			max,
+			maxRange,
+			min,
+			minRange,
+			onChange,
+			precision,
+			pushOnOverlap,
+			restrictToMarks,
+			value
+		]),
+		handleValueCommitted: useCallback(() => {
+			onChangeEnd?.(valueRef.current);
+		}, [onChangeEnd]),
+		rangeValue
+	};
+};
+
+//#endregion
+//#region src/ui/range-slider/range-slider.tsx
+const RangeSlider = (({ className, children, color, defaultValue, domain, hiddenInputProps, inverted = false, label = (value) => value, labelAlwaysOn = false, labelTransitionProps, marks, max = 100, maxRange = Number.POSITIVE_INFINITY, min = 0, minRange = 10, name, onChange, onChangeEnd, precision: precisionProp, pushOnOverlap = true, radius, restrictToMarks = false, scale = (value) => value, size, showLabelOnHover = true, step = 1, style, thumbChildren, thumbFromLabel, thumbLabelOffset, thumbLabelOffsetVertical, thumbProps, thumbSize, thumbToLabel, trackSize, markSize, value, ...props }) => {
+	const { domainMax, domainMin, max: normalizedMax, min: normalizedMin, precision } = resolveSliderBounds({
+		domain,
+		max,
+		min,
+		precision: precisionProp,
+		step
+	});
+	const { handleValueChange, handleValueCommitted, rangeValue } = useRangeSliderState({
+		defaultValue,
+		domainMax,
+		domainMin,
+		marks,
+		max: normalizedMax,
+		maxRange,
+		min: normalizedMin,
+		minRange,
+		onChange,
+		onChangeEnd,
+		precision,
+		pushOnOverlap,
+		restrictToMarks,
+		value
+	});
+	const firstThumbProps = thumbProps?.(0) ?? {};
+	const secondThumbProps = thumbProps?.(1) ?? {};
+	const minStepsBetweenValues = getMinStepsBetweenValues({
+		minRange,
+		restrictToMarks,
+		step
+	});
+	const displayedFromValue = toFloatingValue(scale(rangeValue[0]), precision);
+	const displayedToValue = toFloatingValue(scale(rangeValue[1]), precision);
+	return /* @__PURE__ */ jsxs(Slider.Root, {
+		...props,
+		className: resolveSliderRootClassName(className, inverted),
+		"data-slot": "slider",
+		max: domainMax,
+		min: domainMin,
+		minStepsBetweenValues,
+		onValueChange: handleValueChange,
+		onValueCommitted: handleValueCommitted,
+		step,
+		style: mergeSliderRootStyle({
+			color,
+			markSize,
+			radius,
+			size,
+			thumbLabelOffset,
+			thumbLabelOffsetVertical,
+			thumbSize,
+			trackSize
+		}, style),
+		thumbAlignment: "center",
+		thumbCollisionBehavior: pushOnOverlap ? "push" : "none",
+		value: rangeValue,
+		children: [children ?? /* @__PURE__ */ jsxs(SliderControl, { children: [
+			/* @__PURE__ */ jsxs(SliderTrack, { children: [/* @__PURE__ */ jsx(SliderIndicator, {}), /* @__PURE__ */ jsx(SliderMarks, {
+				disabled: props.disabled,
+				inverted,
+				marks,
+				max: domainMax,
+				min: domainMin,
+				orientation: props.orientation,
+				values: rangeValue
+			})] }),
+			/* @__PURE__ */ jsxs(SliderThumb, {
+				...firstThumbProps,
+				"aria-label": thumbFromLabel,
+				index: 0,
+				children: [getThumbChildrenByIndex(thumbChildren, 0), /* @__PURE__ */ jsx(SliderThumbLabel, {
+					label: resolveSliderLabel(label, displayedFromValue),
+					labelAlwaysOn,
+					orientation: props.orientation,
+					showLabelOnHover,
+					transitionProps: labelTransitionProps
+				})]
+			}),
+			/* @__PURE__ */ jsxs(SliderThumb, {
+				...secondThumbProps,
+				"aria-label": thumbToLabel,
+				index: 1,
+				children: [getThumbChildrenByIndex(thumbChildren, 1), /* @__PURE__ */ jsx(SliderThumbLabel, {
+					label: resolveSliderLabel(label, displayedToValue),
+					labelAlwaysOn,
+					orientation: props.orientation,
+					showLabelOnHover,
+					transitionProps: labelTransitionProps
+				})]
+			})
+		] }), name ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("input", {
+			...hiddenInputProps,
+			name: `${name}_from`,
+			type: "hidden",
+			value: String(displayedFromValue)
+		}), /* @__PURE__ */ jsx("input", {
+			...hiddenInputProps,
+			name: `${name}_to`,
+			type: "hidden",
+			value: String(displayedToValue)
+		})] }) : null]
+	});
+});
+RangeSlider.Control = SliderControl;
+RangeSlider.Indicator = SliderIndicator;
+RangeSlider.Mark = SliderMark;
+RangeSlider.Marks = SliderMarks;
+RangeSlider.Thumb = SliderThumb;
+RangeSlider.ThumbLabel = SliderThumbLabel;
+RangeSlider.Track = SliderTrack;
+RangeSlider.Value = SliderValue;
+
+//#endregion
+export { RangeSlider };
+//# sourceMappingURL=range-slider.js.map