@sprawlify/primitives 0.0.1

package/dist/node-BctU8GXk.d.mts

@@ -0,0 +1,24 @@
+//#region src/shared/dom-query/node.d.ts
+declare const isHTMLElement: (el: any) => el is HTMLElement;
+declare const isDocument: (el: any) => el is Document;
+declare const isWindow: (el: any) => el is Window;
+declare const isVisualViewport: (el: any) => el is VisualViewport;
+declare const getNodeName: (node: Node | Window) => string;
+declare function isRootElement(node: Node): boolean;
+declare const isNode: (el: any) => el is Node;
+declare const isShadowRoot: (el: any) => el is ShadowRoot;
+declare const isInputElement: (el: any) => el is HTMLInputElement;
+declare const isAnchorElement: (el: HTMLElement | null | undefined) => el is HTMLAnchorElement;
+declare const isElementVisible: (el: Node) => boolean;
+declare function isActiveElement(element: Element | null | undefined): boolean;
+declare function isEditableElement(el: HTMLElement | EventTarget | null): boolean;
+type Target = HTMLElement | EventTarget | null | undefined;
+declare function contains(parent: Target, child: Target): boolean;
+declare function getDocument(el: Element | Window | Node | Document | null | undefined): Document;
+declare function getDocumentElement(el: Element | Node | Window | Document | null | undefined): HTMLElement;
+declare function getWindow(el: Node | ShadowRoot | Document | null | undefined): Window & typeof globalThis;
+declare function getActiveElement(rootNode: Document | ShadowRoot): HTMLElement | null;
+declare function getParentNode(node: Node): Node;
+declare function getRootNode(node: Node): Document | ShadowRoot;
+//#endregion
+export { isRootElement as _, getNodeName as a, isWindow as b, getWindow as c, isDocument as d, isEditableElement as f, isNode as g, isInputElement as h, getDocumentElement as i, isActiveElement as l, isHTMLElement as m, getActiveElement as n, getParentNode as o, isElementVisible as p, getDocument as r, getRootNode as s, contains as t, isAnchorElement as u, isShadowRoot as v, isVisualViewport as y };

package/dist/node-CSsuPZVZ.d.cts

@@ -0,0 +1,24 @@
+//#region src/shared/dom-query/node.d.ts
+declare const isHTMLElement: (el: any) => el is HTMLElement;
+declare const isDocument: (el: any) => el is Document;
+declare const isWindow: (el: any) => el is Window;
+declare const isVisualViewport: (el: any) => el is VisualViewport;
+declare const getNodeName: (node: Node | Window) => string;
+declare function isRootElement(node: Node): boolean;
+declare const isNode: (el: any) => el is Node;
+declare const isShadowRoot: (el: any) => el is ShadowRoot;
+declare const isInputElement: (el: any) => el is HTMLInputElement;
+declare const isAnchorElement: (el: HTMLElement | null | undefined) => el is HTMLAnchorElement;
+declare const isElementVisible: (el: Node) => boolean;
+declare function isActiveElement(element: Element | null | undefined): boolean;
+declare function isEditableElement(el: HTMLElement | EventTarget | null): boolean;
+type Target = HTMLElement | EventTarget | null | undefined;
+declare function contains(parent: Target, child: Target): boolean;
+declare function getDocument(el: Element | Window | Node | Document | null | undefined): Document;
+declare function getDocumentElement(el: Element | Node | Window | Document | null | undefined): HTMLElement;
+declare function getWindow(el: Node | ShadowRoot | Document | null | undefined): Window & typeof globalThis;
+declare function getActiveElement(rootNode: Document | ShadowRoot): HTMLElement | null;
+declare function getParentNode(node: Node): Node;
+declare function getRootNode(node: Node): Document | ShadowRoot;
+//#endregion
+export { isRootElement as _, getNodeName as a, isWindow as b, getWindow as c, isDocument as d, isEditableElement as f, isNode as g, isInputElement as h, getDocumentElement as i, isActiveElement as l, isHTMLElement as m, getActiveElement as n, getParentNode as o, isElementVisible as p, getDocument as r, getRootNode as s, contains as t, isAnchorElement as u, isShadowRoot as v, isVisualViewport as y };

package/dist/popper-BPJeAtcA.mjs

@@ -0,0 +1,349 @@
+import { U as raf, Yt as getComputedStyle, ln as isHTMLElement, rn as getWindow } from "./dom-query-DFCRhyj1.mjs";
+import { Y as noop, at as isNull, l as compact } from "./utils-BZyrxWWR.mjs";
+import { arrow, autoUpdate, computePosition, flip, hide, limitShift, offset, shift, size } from "@floating-ui/dom";
+
+//#region src/shared/popper/get-anchor.ts
+function createDOMRect(x = 0, y = 0, width = 0, height = 0) {
+	if (typeof DOMRect === "function") return new DOMRect(x, y, width, height);
+	const rect = {
+		x,
+		y,
+		width,
+		height,
+		top: y,
+		right: x + width,
+		bottom: y + height,
+		left: x
+	};
+	return {
+		...rect,
+		toJSON: () => rect
+	};
+}
+function getDOMRect(anchorRect) {
+	if (!anchorRect) return createDOMRect();
+	const { x, y, width, height } = anchorRect;
+	return createDOMRect(x, y, width, height);
+}
+function getAnchorElement(anchorElement, getAnchorRect) {
+	return {
+		contextElement: isHTMLElement(anchorElement) ? anchorElement : void 0,
+		getBoundingClientRect: () => {
+			const anchor = anchorElement;
+			const anchorRect = getAnchorRect?.(anchor);
+			if (anchorRect || !anchor) return getDOMRect(anchorRect);
+			return anchor.getBoundingClientRect();
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/popper/middleware.ts
+const toVar = (value) => ({
+	variable: value,
+	reference: `var(${value})`
+});
+const cssVars = {
+	arrowSize: toVar("--arrow-size"),
+	arrowSizeHalf: toVar("--arrow-size-half"),
+	arrowBg: toVar("--arrow-background"),
+	transformOrigin: toVar("--transform-origin"),
+	arrowOffset: toVar("--arrow-offset")
+};
+const getSideAxis = (side) => side === "top" || side === "bottom" ? "y" : "x";
+function createTransformOriginMiddleware(opts, arrowEl) {
+	return {
+		name: "transformOrigin",
+		fn(state) {
+			const { elements, middlewareData, placement, rects, y } = state;
+			const side = placement.split("-")[0];
+			const axis = getSideAxis(side);
+			const arrowX = middlewareData.arrow?.x || 0;
+			const arrowY = middlewareData.arrow?.y || 0;
+			const arrowWidth = arrowEl?.clientWidth || 0;
+			const arrowHeight = arrowEl?.clientHeight || 0;
+			const transformX = arrowX + arrowWidth / 2;
+			const transformY = arrowY + arrowHeight / 2;
+			const shiftY = Math.abs(middlewareData.shift?.y || 0);
+			const halfAnchorHeight = rects.reference.height / 2;
+			const arrowOffset = arrowHeight / 2;
+			const gutter = opts.offset?.mainAxis ?? opts.gutter;
+			const sideOffsetValue = typeof gutter === "number" ? gutter + arrowOffset : gutter ?? arrowOffset;
+			const isOverlappingAnchor = shiftY > sideOffsetValue;
+			const adjacentTransformOrigin = {
+				top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,
+				bottom: `${transformX}px ${-sideOffsetValue}px`,
+				left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,
+				right: `${-sideOffsetValue}px ${transformY}px`
+			}[side];
+			const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y}px`;
+			const useOverlap = Boolean(opts.overlap) && axis === "y" && isOverlappingAnchor;
+			elements.floating.style.setProperty(cssVars.transformOrigin.variable, useOverlap ? overlapTransformOrigin : adjacentTransformOrigin);
+			return { data: { transformOrigin: useOverlap ? overlapTransformOrigin : adjacentTransformOrigin } };
+		}
+	};
+}
+const rectMiddleware = {
+	name: "rects",
+	fn({ rects }) {
+		return { data: rects };
+	}
+};
+const shiftArrowMiddleware = (arrowEl) => {
+	if (!arrowEl) return;
+	return {
+		name: "shiftArrow",
+		fn({ placement, middlewareData }) {
+			if (!middlewareData.arrow) return {};
+			const { x, y } = middlewareData.arrow;
+			const dir = placement.split("-")[0];
+			Object.assign(arrowEl.style, {
+				left: x != null ? `${x}px` : "",
+				top: y != null ? `${y}px` : "",
+				[dir]: `calc(100% + ${cssVars.arrowOffset.reference})`
+			});
+			return {};
+		}
+	};
+};
+
+//#endregion
+//#region src/shared/popper/placement.ts
+function isValidPlacement(v) {
+	return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(v);
+}
+function getPlacementDetails(placement) {
+	const [side, align] = placement.split("-");
+	return {
+		side,
+		align,
+		hasAlign: align != null
+	};
+}
+function getPlacementSide(placement) {
+	return placement.split("-")[0];
+}
+
+//#endregion
+//#region src/shared/popper/get-placement.ts
+const defaultOptions = {
+	strategy: "absolute",
+	placement: "bottom",
+	listeners: true,
+	gutter: 8,
+	flip: true,
+	slide: true,
+	overlap: false,
+	sameWidth: false,
+	fitViewport: false,
+	overflowPadding: 8,
+	arrowPadding: 4
+};
+function roundByDpr(win, value) {
+	const dpr = win.devicePixelRatio || 1;
+	return Math.round(value * dpr) / dpr;
+}
+function resolveBoundaryOption(boundary) {
+	if (typeof boundary === "function") return boundary();
+	if (boundary === "clipping-ancestors") return "clippingAncestors";
+	return boundary;
+}
+function getArrowMiddleware(arrowElement, doc, opts) {
+	return arrow({
+		element: arrowElement || doc.createElement("div"),
+		padding: opts.arrowPadding
+	});
+}
+function getOffsetMiddleware(arrowElement, opts) {
+	if (isNull(opts.offset ?? opts.gutter)) return;
+	return offset(({ placement }) => {
+		const arrowOffset = (arrowElement?.clientHeight || 0) / 2;
+		const gutter = opts.offset?.mainAxis ?? opts.gutter;
+		const mainAxis = typeof gutter === "number" ? gutter + arrowOffset : gutter ?? arrowOffset;
+		const { hasAlign } = getPlacementDetails(placement);
+		const shift$1 = !hasAlign ? opts.shift : void 0;
+		return compact({
+			crossAxis: opts.offset?.crossAxis ?? shift$1,
+			mainAxis,
+			alignmentAxis: opts.shift
+		});
+	});
+}
+function getFlipMiddleware(opts) {
+	if (!opts.flip) return;
+	const boundary = resolveBoundaryOption(opts.boundary);
+	return flip({
+		...boundary ? { boundary } : void 0,
+		padding: opts.overflowPadding,
+		fallbackPlacements: opts.flip === true ? void 0 : opts.flip
+	});
+}
+function getShiftMiddleware(opts) {
+	if (!opts.slide && !opts.overlap) return;
+	const boundary = resolveBoundaryOption(opts.boundary);
+	return shift({
+		...boundary ? { boundary } : void 0,
+		mainAxis: opts.slide,
+		crossAxis: opts.overlap,
+		padding: opts.overflowPadding,
+		limiter: limitShift()
+	});
+}
+function getSizeMiddleware(opts) {
+	return size({
+		padding: opts.overflowPadding,
+		apply({ elements, rects, availableHeight, availableWidth }) {
+			const floating = elements.floating;
+			const referenceWidth = Math.round(rects.reference.width);
+			const referenceHeight = Math.round(rects.reference.height);
+			availableWidth = Math.floor(availableWidth);
+			availableHeight = Math.floor(availableHeight);
+			floating.style.setProperty("--reference-width", `${referenceWidth}px`);
+			floating.style.setProperty("--reference-height", `${referenceHeight}px`);
+			floating.style.setProperty("--available-width", `${availableWidth}px`);
+			floating.style.setProperty("--available-height", `${availableHeight}px`);
+		}
+	});
+}
+function hideWhenDetachedMiddleware(opts) {
+	if (!opts.hideWhenDetached) return;
+	return hide({
+		strategy: "referenceHidden",
+		boundary: resolveBoundaryOption(opts.boundary) ?? "clippingAncestors"
+	});
+}
+function getAutoUpdateOptions(opts) {
+	if (!opts) return {};
+	if (opts === true) return {
+		ancestorResize: true,
+		ancestorScroll: true,
+		elementResize: true,
+		layoutShift: true
+	};
+	return opts;
+}
+function getPlacementImpl(referenceOrVirtual, floating, opts = {}) {
+	const reference = getAnchorElement(referenceOrVirtual, opts.getAnchorRect);
+	if (!floating || !reference) return;
+	const options = Object.assign({}, defaultOptions, opts);
+	const arrowEl = floating.querySelector("[data-part=arrow]");
+	const middleware = [
+		getOffsetMiddleware(arrowEl, options),
+		getFlipMiddleware(options),
+		getShiftMiddleware(options),
+		getArrowMiddleware(arrowEl, floating.ownerDocument, options),
+		shiftArrowMiddleware(arrowEl),
+		createTransformOriginMiddleware({
+			gutter: options.gutter,
+			offset: options.offset,
+			overlap: options.overlap
+		}, arrowEl),
+		getSizeMiddleware(options),
+		hideWhenDetachedMiddleware(options),
+		rectMiddleware
+	];
+	const { placement, strategy, onComplete, onPositioned } = options;
+	const updatePosition = async () => {
+		if (!reference || !floating) return;
+		const pos = await computePosition(reference, floating, {
+			placement,
+			middleware,
+			strategy
+		});
+		onComplete?.(pos);
+		onPositioned?.({ placed: true });
+		const win = getWindow(floating);
+		const x = roundByDpr(win, pos.x);
+		const y = roundByDpr(win, pos.y);
+		floating.style.setProperty("--x", `${x}px`);
+		floating.style.setProperty("--y", `${y}px`);
+		if (options.hideWhenDetached) if (pos.middlewareData.hide?.referenceHidden) {
+			floating.style.setProperty("visibility", "hidden");
+			floating.style.setProperty("pointer-events", "none");
+		} else {
+			floating.style.removeProperty("visibility");
+			floating.style.removeProperty("pointer-events");
+		}
+		const contentEl = floating.firstElementChild;
+		if (contentEl) {
+			const styles = getComputedStyle(contentEl);
+			floating.style.setProperty("--z-index", styles.zIndex);
+		}
+	};
+	const update = async () => {
+		if (opts.updatePosition) {
+			await opts.updatePosition({
+				updatePosition,
+				floatingElement: floating
+			});
+			onPositioned?.({ placed: true });
+		} else await updatePosition();
+	};
+	const autoUpdateOptions = getAutoUpdateOptions(options.listeners);
+	const cancelAutoUpdate = options.listeners ? autoUpdate(reference, floating, update, autoUpdateOptions) : noop;
+	update();
+	return () => {
+		cancelAutoUpdate?.();
+		onPositioned?.({ placed: false });
+	};
+}
+function getPlacement(referenceOrFn, floatingOrFn, opts = {}) {
+	const { defer, ...options } = opts;
+	const func = defer ? raf : (v) => v();
+	const cleanups = [];
+	cleanups.push(func(() => {
+		const reference = typeof referenceOrFn === "function" ? referenceOrFn() : referenceOrFn;
+		const floating = typeof floatingOrFn === "function" ? floatingOrFn() : floatingOrFn;
+		cleanups.push(getPlacementImpl(reference, floating, options));
+	}));
+	return () => {
+		cleanups.forEach((fn) => fn?.());
+	};
+}
+
+//#endregion
+//#region src/shared/popper/get-styles.ts
+const ARROW_FLOATING_STYLE = {
+	bottom: "rotate(45deg)",
+	left: "rotate(135deg)",
+	top: "rotate(225deg)",
+	right: "rotate(315deg)"
+};
+function getPlacementStyles(options = {}) {
+	const { placement, sameWidth, fitViewport, strategy = "absolute" } = options;
+	return {
+		arrow: {
+			position: "absolute",
+			width: cssVars.arrowSize.reference,
+			height: cssVars.arrowSize.reference,
+			[cssVars.arrowSizeHalf.variable]: `calc(${cssVars.arrowSize.reference} / 2)`,
+			[cssVars.arrowOffset.variable]: `calc(${cssVars.arrowSizeHalf.reference} * -1)`
+		},
+		arrowTip: {
+			transform: placement ? ARROW_FLOATING_STYLE[placement.split("-")[0]] : void 0,
+			background: cssVars.arrowBg.reference,
+			top: "0",
+			left: "0",
+			width: "100%",
+			height: "100%",
+			position: "absolute",
+			zIndex: "inherit"
+		},
+		floating: {
+			position: strategy,
+			isolation: "isolate",
+			minWidth: sameWidth ? void 0 : "max-content",
+			width: sameWidth ? "var(--reference-width)" : void 0,
+			maxWidth: fitViewport ? "var(--available-width)" : void 0,
+			maxHeight: fitViewport ? "var(--available-height)" : void 0,
+			pointerEvents: !placement ? "none" : void 0,
+			top: "0px",
+			left: "0px",
+			transform: placement ? "translate3d(var(--x), var(--y), 0)" : "translate3d(0, -100vh, 0)",
+			zIndex: "var(--z-index)"
+		}
+	};
+}
+
+//#endregion
+export { isValidPlacement as i, getPlacement as n, getPlacementSide as r, getPlacementStyles as t };