@helsenorge/designsystem-react 14.0.0-beta.9 → 14.0.0

package/lib/floating-ui.react.js

@@ -33,54 +33,30 @@ function isShadowRoot(value) {
 	if (!hasWindow() || typeof ShadowRoot === "undefined") return false;
 	return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
 }
-var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
 function isOverflowElement(element) {
 	const { overflow, overflowX, overflowY, display } = getComputedStyle$1(element);
-	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+	return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
 }
-var tableElements = /* @__PURE__ */ new Set([
-	"table",
-	"td",
-	"th"
-]);
 function isTableElement(element) {
-	return tableElements.has(getNodeName(element));
+	return /^(table|td|th)$/.test(getNodeName(element));
 }
-var topLayerSelectors = [":popover-open", ":modal"];
 function isTopLayer(element) {
-	return topLayerSelectors.some((selector) => {
-		try {
-			return element.matches(selector);
-		} catch (_e) {
-			return false;
-		}
-	});
+	try {
+		if (element.matches(":popover-open")) return true;
+	} catch (_e) {}
+	try {
+		return element.matches(":modal");
+	} catch (_e) {
+		return false;
+	}
 }
-var transformProperties = [
-	"transform",
-	"translate",
-	"scale",
-	"rotate",
-	"perspective"
-];
-var willChangeValues = [
-	"transform",
-	"translate",
-	"scale",
-	"rotate",
-	"perspective",
-	"filter"
-];
-var containValues = [
-	"paint",
-	"layout",
-	"strict",
-	"content"
-];
+var willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+var containRe = /paint|layout|strict|content/;
+var isNotNone = (value) => !!value && value !== "none";
+var isWebKitValue;
 function isContainingBlock(elementOrCss) {
-	const webkit = isWebKit();
 	const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
-	return transformProperties.some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.some((value) => (css.contain || "").includes(value));
+	return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
 }
 function getContainingBlock(element) {
 	let currentNode = getParentNode(element);
@@ -92,16 +68,11 @@ function getContainingBlock(element) {
 	return null;
 }
 function isWebKit() {
-	if (typeof CSS === "undefined" || !CSS.supports) return false;
-	return CSS.supports("-webkit-backdrop-filter", "none");
-}
-var lastTraversableNodeNames = /* @__PURE__ */ new Set([
-	"html",
-	"body",
-	"#document"
-]);
+	if (isWebKitValue == null) isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
+	return isWebKitValue;
+}
 function isLastTraversableNode(node) {
-	return lastTraversableNodeNames.has(getNodeName(node));
+	return /^(html|body|#document)$/.test(getNodeName(node));
 }
 function getComputedStyle$1(element) {
 	return getWindow(element).getComputedStyle(element);
@@ -137,8 +108,7 @@ function getOverflowAncestors(node, list, traverseIframes) {
 	if (isBody) {
 		const frameElement = getFrameElement(win);
 		return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-	}
-	return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+	} else return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
 }
 function getFrameElement(win) {
 	return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
@@ -163,10 +133,6 @@ var oppositeSideMap = {
 	bottom: "top",
 	top: "bottom"
 };
-var oppositeAlignmentMap = {
-	start: "end",
-	end: "start"
-};
 function clamp(start, value, end) {
 	return max(start, min(value, end));
 }
@@ -185,9 +151,9 @@ function getOppositeAxis(axis) {
 function getAxisLength(axis) {
 	return axis === "y" ? "height" : "width";
 }
-var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
 function getSideAxis(placement) {
-	return yAxisSides.has(getSide(placement)) ? "y" : "x";
+	const firstChar = placement[0];
+	return firstChar === "t" || firstChar === "b" ? "y" : "x";
 }
 function getAlignmentAxis(placement) {
 	return getOppositeAxis(getSideAxis(placement));
@@ -210,7 +176,7 @@ function getExpandedPlacements(placement) {
 	];
 }
 function getOppositeAlignmentPlacement(placement) {
-	return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+	return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
 }
 var lrPlacement = ["left", "right"];
 var rlPlacement = ["right", "left"];
@@ -237,7 +203,8 @@ function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
 	return list;
 }
 function getOppositePlacement(placement) {
-	return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+	const side = getSide(placement);
+	return oppositeSideMap[side] + placement.slice(side.length);
 }
 function expandPaddingObject(padding) {
 	return {
@@ -785,9 +752,13 @@ async function detectOverflow$1(state, options) {
 		right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
 	};
 }
+var MAX_RESET_COUNT = 50;
 var computePosition$1 = async (reference, floating, config) => {
 	const { placement = "bottom", strategy = "absolute", middleware = [], platform: platform$1 } = config;
-	const validMiddleware = middleware.filter(Boolean);
+	const platformWithDetectOverflow = platform$1.detectOverflow ? platform$1 : {
+		...platform$1,
+		detectOverflow: detectOverflow$1
+	};
 	const rtl = await (platform$1.isRTL == null ? void 0 : platform$1.isRTL(floating));
 	let rects = await platform$1.getElementRects({
 		reference,
@@ -796,11 +767,12 @@ var computePosition$1 = async (reference, floating, config) => {
 	});
 	let { x, y } = computeCoordsFromPlacement(rects, placement, rtl);
 	let statefulPlacement = placement;
-	let middlewareData = {};
 	let resetCount = 0;
-	for (let i = 0; i < validMiddleware.length; i++) {
-		var _platform$detectOverf;
-		const { name, fn } = validMiddleware[i];
+	const middlewareData = {};
+	for (let i = 0; i < middleware.length; i++) {
+		const currentMiddleware = middleware[i];
+		if (!currentMiddleware) continue;
+		const { name, fn } = currentMiddleware;
 		const { x: nextX, y: nextY, data, reset } = await fn({
 			x,
 			y,
@@ -809,10 +781,7 @@ var computePosition$1 = async (reference, floating, config) => {
 			strategy,
 			middlewareData,
 			rects,
-			platform: {
-				...platform$1,
-				detectOverflow: (_platform$detectOverf = platform$1.detectOverflow) != null ? _platform$detectOverf : detectOverflow$1
-			},
+			platform: platformWithDetectOverflow,
 			elements: {
 				reference,
 				floating
@@ -820,14 +789,11 @@ var computePosition$1 = async (reference, floating, config) => {
 		});
 		x = nextX != null ? nextX : x;
 		y = nextY != null ? nextY : y;
-		middlewareData = {
-			...middlewareData,
-			[name]: {
-				...middlewareData[name],
-				...data
-			}
+		middlewareData[name] = {
+			...middlewareData[name],
+			...data
 		};
-		if (reset && resetCount <= 50) {
+		if (reset && resetCount < MAX_RESET_COUNT) {
 			resetCount++;
 			if (typeof reset === "object") {
 				if (reset.placement) statefulPlacement = reset.placement;
@@ -1280,7 +1246,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
 	const isOffsetParentAnElement = isHTMLElement(offsetParent);
 	if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
 		if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
-		if (isHTMLElement(offsetParent)) {
+		if (isOffsetParentAnElement) {
 			const offsetRect = getBoundingClientRect(offsetParent);
 			scale = getScale(offsetParent);
 			offsets.x = offsetRect.x + offsetParent.clientLeft;
@@ -1348,7 +1314,6 @@ function getViewportRect(element, strategy) {
 		y
 	};
 }
-var absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
 function getInnerBoundingClientRect(element, strategy) {
 	const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
 	const top = clientRect.top + element.clientTop;
@@ -1393,7 +1358,7 @@ function getClippingElementAncestors(element, cache) {
 		const computedStyle = getComputedStyle$1(currentNode);
 		const currentNodeIsContaining = isContainingBlock(currentNode);
 		if (!currentNodeIsContaining && computedStyle.position === "fixed") currentContainingBlockComputedStyle = null;
-		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
+		if (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) result = result.filter((ancestor) => ancestor !== currentNode);
 		else currentContainingBlockComputedStyle = computedStyle;
 		currentNode = getParentNode(currentNode);
 	}
@@ -1403,20 +1368,23 @@ function getClippingElementAncestors(element, cache) {
 function getClippingRect(_ref) {
 	let { element, boundary, rootBoundary, strategy } = _ref;
 	const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary];
-	const firstClippingAncestor = clippingAncestors[0];
-	const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-		const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-		accRect.top = max(rect.top, accRect.top);
-		accRect.right = min(rect.right, accRect.right);
-		accRect.bottom = min(rect.bottom, accRect.bottom);
-		accRect.left = max(rect.left, accRect.left);
-		return accRect;
-	}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+	const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+	let top = firstRect.top;
+	let right = firstRect.right;
+	let bottom = firstRect.bottom;
+	let left = firstRect.left;
+	for (let i = 1; i < clippingAncestors.length; i++) {
+		const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
+		top = max(rect.top, top);
+		right = min(rect.right, right);
+		bottom = min(rect.bottom, bottom);
+		left = max(rect.left, left);
+	}
 	return {
-		width: clippingRect.right - clippingRect.left,
-		height: clippingRect.bottom - clippingRect.top,
-		x: clippingRect.left,
-		y: clippingRect.top
+		width: right - left,
+		height: bottom - top,
+		x: left,
+		y: top
 	};
 }
 function getDimensions(element) {
@@ -1570,7 +1538,7 @@ function autoUpdate(reference, floating, update, options) {
 	if (options === void 0) options = {};
 	const { ancestorScroll = true, ancestorResize = true, elementResize = typeof ResizeObserver === "function", layoutShift = typeof IntersectionObserver === "function", animationFrame = false } = options;
 	const referenceEl = unwrapElement(reference);
-	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+	const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
 	ancestors.forEach((ancestor) => {
 		ancestorScroll && ancestor.addEventListener("scroll", update, { passive: true });
 		ancestorResize && ancestor.addEventListener("resize", update);
@@ -1581,7 +1549,7 @@ function autoUpdate(reference, floating, update, options) {
 	if (elementResize) {
 		resizeObserver = new ResizeObserver((_ref) => {
 			let [firstEntry] = _ref;
-			if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+			if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
 				resizeObserver.unobserve(floating);
 				cancelAnimationFrame(reobserveFrame);
 				reobserveFrame = requestAnimationFrame(() => {
@@ -1592,7 +1560,7 @@ function autoUpdate(reference, floating, update, options) {
 			update();
 		});
 		if (referenceEl && !animationFrame) resizeObserver.observe(referenceEl);
-		resizeObserver.observe(floating);
+		if (floating) resizeObserver.observe(floating);
 	}
 	let frameId;
 	let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
@@ -1847,30 +1815,54 @@ var arrow$1$1 = (options) => {
 		}
 	};
 };
-var offset = (options, deps) => ({
-	...offset$1(options),
-	options: [options, deps]
-});
-var shift = (options, deps) => ({
-	...shift$1(options),
-	options: [options, deps]
-});
-var flip = (options, deps) => ({
-	...flip$1(options),
-	options: [options, deps]
-});
-var size = (options, deps) => ({
-	...size$1(options),
-	options: [options, deps]
-});
-var hide = (options, deps) => ({
-	...hide$1(options),
-	options: [options, deps]
-});
-var arrow = (options, deps) => ({
-	...arrow$1$1(options),
-	options: [options, deps]
-});
+var offset = (options, deps) => {
+	const result = offset$1(options);
+	return {
+		name: result.name,
+		fn: result.fn,
+		options: [options, deps]
+	};
+};
+var shift = (options, deps) => {
+	const result = shift$1(options);
+	return {
+		name: result.name,
+		fn: result.fn,
+		options: [options, deps]
+	};
+};
+var flip = (options, deps) => {
+	const result = flip$1(options);
+	return {
+		name: result.name,
+		fn: result.fn,
+		options: [options, deps]
+	};
+};
+var size = (options, deps) => {
+	const result = size$1(options);
+	return {
+		name: result.name,
+		fn: result.fn,
+		options: [options, deps]
+	};
+};
+var hide = (options, deps) => {
+	const result = hide$1(options);
+	return {
+		name: result.name,
+		fn: result.fn,
+		options: [options, deps]
+	};
+};
+var arrow = (options, deps) => {
+	const result = arrow$1$1(options);
+	return {
+		name: result.name,
+		fn: result.fn,
+		options: [options, deps]
+	};
+};
 function useMergeRefs(refs) {
 	const cleanupRef = React$1.useRef(void 0);
 	const refEffect = React$1.useCallback((instance) => {
@@ -2423,7 +2415,10 @@ var uncontrolledElementsSet = /* @__PURE__ */ new WeakSet();
 var markerMap = {};
 var lockCount$1 = 0;
 var supportsInert = () => typeof HTMLElement !== "undefined" && "inert" in HTMLElement.prototype;
-var unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+function unwrapHost(node) {
+	if (!node) return null;
+	return isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
+}
 var correctElements = (parent, targets) => targets.map((target) => {
 	if (parent.contains(target)) return target;
 	const correctedTarget = unwrapHost(target);
@@ -2551,7 +2546,7 @@ function addPreviouslyFocusedElement(element) {
 	clearDisconnectedPreviouslyFocusedElements();
 	if (element && getNodeName(element) !== "body") {
 		previouslyFocusedElements.push(new WeakRef(element));
-		if (previouslyFocusedElements.length > LIST_LIMIT) previouslyFocusedElements = previouslyFocusedElements.slice(-20);
+		if (previouslyFocusedElements.length > LIST_LIMIT) previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
 	}
 }
 function getPreviouslyFocusedElement() {
@@ -3244,18 +3239,20 @@ function useDismiss(context, props) {
 		referencePress,
 		referencePressEvent
 	]);
-	const floating = React$1.useMemo(() => ({
-		onKeyDown: closeOnEscapeKeyDown,
-		onMouseDown() {
-			endedOrStartedInsideRef.current = true;
-		},
-		onMouseUp() {
+	const floating = React$1.useMemo(() => {
+		function setMouseDownOrUpInside(event) {
+			if (event.button !== 0) return;
 			endedOrStartedInsideRef.current = true;
-		},
-		[captureHandlerKeys[outsidePressEvent]]: () => {
-			dataRef.current.insideReactTree = true;
 		}
-	}), [
+		return {
+			onKeyDown: closeOnEscapeKeyDown,
+			onMouseDown: setMouseDownOrUpInside,
+			onMouseUp: setMouseDownOrUpInside,
+			[captureHandlerKeys[outsidePressEvent]]: () => {
+				dataRef.current.insideReactTree = true;
+			}
+		};
+	}, [
 		closeOnEscapeKeyDown,
 		outsidePressEvent,
 		dataRef