bits-ui 2.2.0 → 2.2.1

package/dist/bits/slider/helpers.js

@@ -132,6 +132,29 @@ export function getThumbLabelStyles(direction, thumbPosition, labelPosition = "t
     }
     return style;
 }
+/**
+ * Gets the number of decimal places in a number
+ */
+function getDecimalPlaces(num) {
+    if (Math.floor(num) === num)
+        return 0;
+    const str = num.toString();
+    if (str.indexOf(".") !== -1 && str.indexOf("e-") === -1) {
+        return str.split(".")[1].length;
+    }
+    else if (str.indexOf("e-") !== -1) {
+        const parts = str.split("e-");
+        return parseInt(parts[1], 10);
+    }
+    return 0;
+}
+/**
+ * Rounds a number to the specified number of decimal places
+ */
+function roundToPrecision(num, precision) {
+    const factor = Math.pow(10, precision);
+    return Math.round(num * factor) / factor;
+}
 /**
  * Normalizes step to always be a sorted array of valid values within min/max range
  */
@@ -140,13 +163,21 @@ export function normalizeSteps(step, min, max) {
         // generate regular steps - match original behavior exactly
         const difference = max - min;
         let count = Math.ceil(difference / step);
-        if (difference % step === 0) {
+        // Get precision from step to avoid floating point errors
+        const precision = getDecimalPlaces(step);
+        // Check if difference is divisible by step using integer arithmetic to avoid floating point errors
+        const factor = Math.pow(10, precision);
+        const intDifference = Math.round(difference * factor);
+        const intStep = Math.round(step * factor);
+        if (intDifference % intStep === 0) {
             count++;
         }
         const steps = [];
         for (let i = 0; i < count; i++) {
             const value = min + i * step;
-            steps.push(value);
+            // Round to the precision of the step to avoid floating point errors
+            const roundedValue = roundToPrecision(value, precision);
+            steps.push(roundedValue);
         }
         return steps;
     }

package/dist/bits/tooltip/components/tooltip-content-static.svelte

@@ -46,6 +46,7 @@
 		preventScroll={false}
 		forceMount={true}
 		ref={contentState.opts.ref}
+		tooltip={true}
 	>
 		{#snippet popper({ props })}
 			{@const mergedProps = mergeProps(props, {
@@ -64,6 +65,7 @@
 	<PopperLayer
 		{...mergedProps}
 		{...contentState.popperProps}
+		tooltip={true}
 		isStatic
 		present={contentState.root.opts.open.current}
 		{id}

package/dist/bits/tooltip/components/tooltip-content.svelte

@@ -64,6 +64,7 @@
 		preventScroll={false}
 		forceMount={true}
 		ref={contentState.opts.ref}
+		tooltip={true}
 	>
 		{#snippet popper({ props, wrapperProps })}
 			{@const mergedProps = mergeProps(props, {
@@ -91,6 +92,7 @@
 		preventScroll={false}
 		forceMount={false}
 		ref={contentState.opts.ref}
+		tooltip={true}
 	>
 		{#snippet popper({ props, wrapperProps })}
 			{@const mergedProps = mergeProps(props, {

package/dist/bits/tooltip/components/tooltip-trigger.svelte

@@ -29,7 +29,7 @@
 	const mergedProps = $derived(mergeProps(restProps, triggerState.props, { type }));
 </script>
 
-<FloatingLayerAnchor {id} ref={triggerState.opts.ref}>
+<FloatingLayerAnchor {id} ref={triggerState.opts.ref} tooltip={true}>
 	{#if child}
 		{@render child({ props: mergedProps })}
 	{:else}

package/dist/bits/tooltip/components/tooltip.svelte

@@ -32,6 +32,6 @@
 	});
 </script>
 
-<FloatingLayer>
+<FloatingLayer tooltip>
 	{@render children?.()}
 </FloatingLayer>

package/dist/bits/tooltip/tooltip.svelte.d.ts

@@ -1,7 +1,7 @@
 import { DOMContext } from "svelte-toolbelt";
 import type { ReadableBoxedValues, WritableBoxedValues } from "../../internal/box.svelte.js";
 import type { WithRefProps } from "../../internal/types.js";
-import type { PointerEventHandler } from "svelte/elements";
+import type { FocusEventHandler, MouseEventHandler, PointerEventHandler } from "svelte/elements";
 type TooltipProviderStateProps = ReadableBoxedValues<{
     delayDuration: number;
     disableHoverableContent: boolean;
@@ -58,23 +58,21 @@ declare class TooltipTriggerState {
     constructor(opts: TooltipTriggerStateProps, root: TooltipRootState);
     handlePointerUp: () => void;
     props: {
-        id: string;
-        "aria-describedby": string | undefined;
-        "data-state": string;
-        "data-disabled": "" | undefined;
-        "data-delay-duration": string;
-        "data-tooltip-trigger": string;
-        tabindex: number | undefined;
-        disabled: boolean;
-        onpointerup: () => void;
-        onpointerdown: () => void;
-        onpointermove: PointerEventHandler<HTMLElement>;
-        onpointerleave: () => void;
-        onfocus: (e: FocusEvent & {
-            currentTarget: HTMLElement;
-        }) => void;
-        onblur: () => void;
-        onclick: () => void;
+        readonly id: string;
+        readonly "aria-describedby": string | undefined;
+        readonly "data-state": string;
+        readonly "data-disabled": "" | undefined;
+        readonly "data-delay-duration": `${number}`;
+        readonly "data-tooltip-trigger": "";
+        readonly tabindex: 0 | undefined;
+        readonly disabled: boolean;
+        readonly onpointerup: PointerEventHandler<HTMLElement>;
+        readonly onpointerdown: PointerEventHandler<HTMLElement>;
+        readonly onpointermove: PointerEventHandler<HTMLElement>;
+        readonly onpointerleave: PointerEventHandler<HTMLElement>;
+        readonly onfocus: FocusEventHandler<HTMLElement>;
+        readonly onblur: FocusEventHandler<HTMLElement>;
+        readonly onclick: MouseEventHandler<HTMLElement>;
     };
 }
 type TooltipContentStateProps = WithRefProps & ReadableBoxedValues<{

package/dist/bits/tooltip/tooltip.svelte.js

@@ -194,7 +194,9 @@ class TooltipTriggerState {
     };
     props = $derived.by(() => ({
         id: this.opts.id.current,
-        "aria-describedby": this.root.opts.open.current ? this.root.contentNode?.id : undefined,
+        "aria-describedby": this.root.opts.open.current
+            ? this.root.contentNode?.id
+            : undefined,
         "data-state": this.root.stateAttr,
         "data-disabled": getDataDisabled(this.#isDisabled),
         "data-delay-duration": `${this.root.delayDuration}`,

package/dist/bits/utilities/floating-layer/components/floating-layer-anchor.svelte

@@ -4,13 +4,16 @@
 	import type { AnchorProps } from "./index.js";
 	import type { Measurable } from "../../../../internal/floating-svelte/types.js";
 
-	let { id, children, virtualEl, ref }: AnchorProps = $props();
+	let { id, children, virtualEl, ref, tooltip = false }: AnchorProps = $props();
 
-	useFloatingAnchorState({
-		id: box.with(() => id),
-		virtualEl: box.with(() => virtualEl as unknown as Measurable | null),
-		ref,
-	});
+	useFloatingAnchorState(
+		{
+			id: box.with(() => id),
+			virtualEl: box.with(() => virtualEl as unknown as Measurable | null),
+			ref,
+		},
+		tooltip
+	);
 </script>
 
 {@render children?.()}

package/dist/bits/utilities/floating-layer/components/floating-layer-content.svelte

@@ -25,29 +25,33 @@
 		wrapperId = useId(),
 		customAnchor = null,
 		enabled,
+		tooltip = false,
 	}: ContentImplProps = $props();
 
-	const contentState = useFloatingContentState({
-		side: box.with(() => side),
-		sideOffset: box.with(() => sideOffset),
-		align: box.with(() => align),
-		alignOffset: box.with(() => alignOffset),
-		id: box.with(() => id),
-		arrowPadding: box.with(() => arrowPadding),
-		avoidCollisions: box.with(() => avoidCollisions),
-		collisionBoundary: box.with(() => collisionBoundary),
-		collisionPadding: box.with(() => collisionPadding),
-		hideWhenDetached: box.with(() => hideWhenDetached),
-		onPlaced: box.with(() => onPlaced),
-		sticky: box.with(() => sticky),
-		updatePositionStrategy: box.with(() => updatePositionStrategy),
-		strategy: box.with(() => strategy),
-		dir: box.with(() => dir),
-		style: box.with(() => style),
-		enabled: box.with(() => enabled),
-		wrapperId: box.with(() => wrapperId),
-		customAnchor: box.with(() => customAnchor),
-	});
+	const contentState = useFloatingContentState(
+		{
+			side: box.with(() => side),
+			sideOffset: box.with(() => sideOffset),
+			align: box.with(() => align),
+			alignOffset: box.with(() => alignOffset),
+			id: box.with(() => id),
+			arrowPadding: box.with(() => arrowPadding),
+			avoidCollisions: box.with(() => avoidCollisions),
+			collisionBoundary: box.with(() => collisionBoundary),
+			collisionPadding: box.with(() => collisionPadding),
+			hideWhenDetached: box.with(() => hideWhenDetached),
+			onPlaced: box.with(() => onPlaced),
+			sticky: box.with(() => sticky),
+			updatePositionStrategy: box.with(() => updatePositionStrategy),
+			strategy: box.with(() => strategy),
+			dir: box.with(() => dir),
+			style: box.with(() => style),
+			enabled: box.with(() => enabled),
+			wrapperId: box.with(() => wrapperId),
+			customAnchor: box.with(() => customAnchor),
+		},
+		tooltip
+	);
 
 	const mergedProps = $derived(
 		mergeProps(contentState.wrapperProps, {

package/dist/bits/utilities/floating-layer/components/floating-layer.svelte

@@ -2,9 +2,9 @@
 	import type { Snippet } from "svelte";
 	import { useFloatingRootState } from "../use-floating-layer.svelte.js";
 
-	let { children }: { children?: Snippet } = $props();
+	let { children, tooltip = false }: { children?: Snippet; tooltip?: boolean } = $props();
 
-	useFloatingRootState();
+	useFloatingRootState(tooltip);
 </script>
 
 {@render children?.()}

package/dist/bits/utilities/floating-layer/components/floating-layer.svelte.d.ts

@@ -1,6 +1,7 @@
 import type { Snippet } from "svelte";
 type $$ComponentProps = {
     children?: Snippet;
+    tooltip?: boolean;
 };
 declare const FloatingLayer: import("svelte").Component<$$ComponentProps, {}, "">;
 type FloatingLayer = ReturnType<typeof FloatingLayer>;

package/dist/bits/utilities/floating-layer/types.d.ts

@@ -107,10 +107,28 @@ export type FloatingLayerContentImplProps = {
      */
     onPlaced?: () => void;
     enabled: boolean;
+    /**
+     * Tooltips are special in that they are commonly composed
+     * with other floating components, where the same trigger is
+     * used for both the tooltip and the popover.
+     *
+     * For situations like this, we need to use a different context
+     * symbol so that conflicts don't occur.
+     */
+    tooltip?: boolean;
 } & FloatingLayerContentProps;
 export type FloatingLayerAnchorProps = {
     id: string;
     children?: Snippet;
     virtualEl?: ReadableBox<Measurable | null>;
     ref: ReadableBox<HTMLElement | null>;
+    /**
+     * Tooltips are special in that they are commonly composed
+     * with other floating components, where the same trigger is
+     * used for both the tooltip and the popover.
+     *
+     * For situations like this, we need to use a different context
+     * symbol so that conflicts don't occur.
+     */
+    tooltip?: boolean;
 };

package/dist/bits/utilities/floating-layer/use-floating-layer.svelte.d.ts

@@ -942,10 +942,10 @@ declare class FloatingAnchorState {
     readonly root: FloatingRootState;
     constructor(opts: FloatingAnchorStateProps, root: FloatingRootState);
 }
-export declare function useFloatingRootState(): FloatingRootState;
-export declare function useFloatingContentState(props: FloatingContentStateProps): FloatingContentState;
+export declare function useFloatingRootState(tooltip?: boolean): FloatingRootState;
+export declare function useFloatingContentState(props: FloatingContentStateProps, tooltip?: boolean): FloatingContentState;
 export declare function useFloatingArrowState(props: FloatingArrowStateProps): FloatingArrowState;
-export declare function useFloatingAnchorState(props: FloatingAnchorStateProps): FloatingAnchorState;
+export declare function useFloatingAnchorState(props: FloatingAnchorStateProps, tooltip?: boolean): FloatingAnchorState;
 export declare function getSideFromPlacement(placement: Placement): "left" | "right" | "top" | "bottom";
 export declare function getAlignFromPlacement(placement: Placement): "end" | "center" | "start";
 export {};

package/dist/bits/utilities/floating-layer/use-floating-layer.svelte.js

@@ -140,9 +140,6 @@ class FloatingContentState {
         "data-align": this.placedAlign,
         style: styleToString({
             ...this.#transformedStyle,
-            // if the FloatingContent hasn't been placed yet (not all measurements done)
-            // we prevent animations so that users's animation don't kick in too early referring wrong sides
-            // animation: !this.floating.isPositioned ? "none" : undefined,
         }),
         ...attachRef(this.contentRef),
     }));
@@ -233,17 +230,24 @@ class FloatingAnchorState {
 }
 const FloatingRootContext = new Context("Floating.Root");
 const FloatingContentContext = new Context("Floating.Content");
-export function useFloatingRootState() {
-    return FloatingRootContext.set(new FloatingRootState());
+const FloatingTooltipRootContext = new Context("Floating.Root");
+export function useFloatingRootState(tooltip = false) {
+    return tooltip
+        ? FloatingTooltipRootContext.set(new FloatingRootState())
+        : FloatingRootContext.set(new FloatingRootState());
 }
-export function useFloatingContentState(props) {
-    return FloatingContentContext.set(new FloatingContentState(props, FloatingRootContext.get()));
+export function useFloatingContentState(props, tooltip = false) {
+    return tooltip
+        ? FloatingContentContext.set(new FloatingContentState(props, FloatingTooltipRootContext.get()))
+        : FloatingContentContext.set(new FloatingContentState(props, FloatingRootContext.get()));
 }
 export function useFloatingArrowState(props) {
     return new FloatingArrowState(props, FloatingContentContext.get());
 }
-export function useFloatingAnchorState(props) {
-    return new FloatingAnchorState(props, FloatingRootContext.get());
+export function useFloatingAnchorState(props, tooltip = false) {
+    return tooltip
+        ? new FloatingAnchorState(props, FloatingTooltipRootContext.get())
+        : new FloatingAnchorState(props, FloatingRootContext.get());
 }
 //
 // HELPERS

package/dist/bits/utilities/popper-layer/popper-layer-inner.svelte

@@ -45,6 +45,7 @@
 		isStatic = false,
 		enabled,
 		ref,
+		tooltip = false,
 		...restProps
 	}: Omit<PopperLayerImplProps, "present" | "children"> & {
 		enabled: boolean;
@@ -72,6 +73,7 @@
 	{onPlaced}
 	{customAnchor}
 	{enabled}
+	{tooltip}
 >
 	{#snippet content({ props: floatingProps, wrapperProps })}
 		{#if restProps.forceMount && enabled}

package/dist/bits/utilities/popper-layer/types.d.ts

@@ -22,4 +22,13 @@ export type PopperLayerImplProps = Omit<EscapeLayerImplProps & DismissibleLayerI
         }
     ]>;
     isStatic?: boolean;
+    /**
+     * Tooltips are special in that they are commonly composed
+     * with other floating components, where the same trigger is
+     * used for both the tooltip and the popover.
+     *
+     * For situations like this, we need to use a different context
+     * symbol so that conflicts don't occur.
+     */
+    tooltip?: boolean;
 }, "enabled">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bits-ui",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "license": "MIT",
   "repository": "github:huntabyte/bits-ui",
   "funding": "https://github.com/sponsors/huntabyte",