@sprawlify/primitives 0.0.1

package/dist/popper-D0FAW_p7.cjs

@@ -0,0 +1,373 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_dom_query = require('./dom-query-CWZdWUGp.cjs');
+const require_utils = require('./utils-_6frwjgJ.cjs');
+let __floating_ui_dom = require("@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: require_dom_query.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 (0, __floating_ui_dom.arrow)({
+		element: arrowElement || doc.createElement("div"),
+		padding: opts.arrowPadding
+	});
+}
+function getOffsetMiddleware(arrowElement, opts) {
+	if (require_utils.isNull(opts.offset ?? opts.gutter)) return;
+	return (0, __floating_ui_dom.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 require_utils.compact({
+			crossAxis: opts.offset?.crossAxis ?? shift$1,
+			mainAxis,
+			alignmentAxis: opts.shift
+		});
+	});
+}
+function getFlipMiddleware(opts) {
+	if (!opts.flip) return;
+	const boundary = resolveBoundaryOption(opts.boundary);
+	return (0, __floating_ui_dom.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 (0, __floating_ui_dom.shift)({
+		...boundary ? { boundary } : void 0,
+		mainAxis: opts.slide,
+		crossAxis: opts.overlap,
+		padding: opts.overflowPadding,
+		limiter: (0, __floating_ui_dom.limitShift)()
+	});
+}
+function getSizeMiddleware(opts) {
+	return (0, __floating_ui_dom.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 (0, __floating_ui_dom.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 (0, __floating_ui_dom.computePosition)(reference, floating, {
+			placement,
+			middleware,
+			strategy
+		});
+		onComplete?.(pos);
+		onPositioned?.({ placed: true });
+		const win = require_dom_query.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 = require_dom_query.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 ? (0, __floating_ui_dom.autoUpdate)(reference, floating, update, autoUpdateOptions) : require_utils.noop;
+	update();
+	return () => {
+		cancelAutoUpdate?.();
+		onPositioned?.({ placed: false });
+	};
+}
+function getPlacement(referenceOrFn, floatingOrFn, opts = {}) {
+	const { defer, ...options } = opts;
+	const func = defer ? require_dom_query.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
+Object.defineProperty(exports, 'getPlacement', {
+  enumerable: true,
+  get: function () {
+    return getPlacement;
+  }
+});
+Object.defineProperty(exports, 'getPlacementSide', {
+  enumerable: true,
+  get: function () {
+    return getPlacementSide;
+  }
+});
+Object.defineProperty(exports, 'getPlacementStyles', {
+  enumerable: true,
+  get: function () {
+    return getPlacementStyles;
+  }
+});
+Object.defineProperty(exports, 'isValidPlacement', {
+  enumerable: true,
+  get: function () {
+    return isValidPlacement;
+  }
+});

package/dist/popper.cjs

@@ -0,0 +1,8 @@
+require('./dom-query-CWZdWUGp.cjs');
+require('./utils-_6frwjgJ.cjs');
+const require_popper = require('./popper-D0FAW_p7.cjs');
+
+exports.getPlacement = require_popper.getPlacement;
+exports.getPlacementSide = require_popper.getPlacementSide;
+exports.getPlacementStyles = require_popper.getPlacementStyles;
+exports.isValidPlacement = require_popper.isValidPlacement;

package/dist/popper.d.cts

@@ -0,0 +1,74 @@
+import { a as MaybeElement, c as Placement, d as PositioningOptions, i as ComputePositionReturn, l as PlacementAlign, n as AutoUpdateOptions, o as MaybeFn, r as Boundary, s as MaybeRectElement, t as AnchorRect, u as PlacementSide } from "./types-DiIdKZ3K.cjs";
+import { Placement as Placement$1 } from "@floating-ui/dom";
+
+//#region src/shared/popper/get-placement.d.ts
+declare function getPlacement(referenceOrFn: MaybeFn<MaybeRectElement>, floatingOrFn: MaybeFn<MaybeElement>, opts?: PositioningOptions & {
+  defer?: boolean | undefined;
+}): () => void;
+//#endregion
+//#region src/shared/popper/middleware.d.ts
+declare const cssVars: {
+  arrowSize: {
+    variable: string;
+    reference: string;
+  };
+  arrowSizeHalf: {
+    variable: string;
+    reference: string;
+  };
+  arrowBg: {
+    variable: string;
+    reference: string;
+  };
+  transformOrigin: {
+    variable: string;
+    reference: string;
+  };
+  arrowOffset: {
+    variable: string;
+    reference: string;
+  };
+};
+//#endregion
+//#region src/shared/popper/get-styles.d.ts
+interface GetPlacementStylesOptions {
+  placement?: Placement$1 | undefined;
+}
+declare function getPlacementStyles(options?: Pick<PositioningOptions, "placement" | "sameWidth" | "fitViewport" | "strategy">): {
+  arrow: {
+    readonly [cssVars.arrowSizeHalf.variable]: `calc(${string} / 2)`;
+    readonly [cssVars.arrowOffset.variable]: `calc(${string} * -1)`;
+    readonly position: "absolute";
+    readonly width: string;
+    readonly height: string;
+  };
+  arrowTip: {
+    readonly transform: any;
+    readonly background: string;
+    readonly top: "0";
+    readonly left: "0";
+    readonly width: "100%";
+    readonly height: "100%";
+    readonly position: "absolute";
+    readonly zIndex: "inherit";
+  };
+  floating: {
+    readonly position: "absolute" | "fixed";
+    readonly isolation: "isolate";
+    readonly minWidth: "max-content" | undefined;
+    readonly width: "var(--reference-width)" | undefined;
+    readonly maxWidth: "var(--available-width)" | undefined;
+    readonly maxHeight: "var(--available-height)" | undefined;
+    readonly pointerEvents: "none" | undefined;
+    readonly top: "0px";
+    readonly left: "0px";
+    readonly transform: "translate3d(var(--x), var(--y), 0)" | "translate3d(0, -100vh, 0)";
+    readonly zIndex: "var(--z-index)";
+  };
+};
+//#endregion
+//#region src/shared/popper/placement.d.ts
+declare function isValidPlacement(v: string): v is Placement$1;
+declare function getPlacementSide(placement: Placement$1): PlacementSide;
+//#endregion
+export { AnchorRect, AutoUpdateOptions, Boundary, ComputePositionReturn, GetPlacementStylesOptions, Placement, PlacementAlign, PlacementSide, PositioningOptions, getPlacement, getPlacementSide, getPlacementStyles, isValidPlacement };

package/dist/popper.d.mts

@@ -0,0 +1,2 @@
+import { a as getPlacement, c as Boundary, d as PlacementAlign, f as PlacementSide, i as getPlacementStyles, l as ComputePositionReturn, n as isValidPlacement, o as AnchorRect, p as PositioningOptions, r as GetPlacementStylesOptions, s as AutoUpdateOptions, t as getPlacementSide, u as Placement } from "./index-D96rs8B0.mjs";
+export { AnchorRect, AutoUpdateOptions, Boundary, ComputePositionReturn, GetPlacementStylesOptions, Placement, PlacementAlign, PlacementSide, PositioningOptions, getPlacement, getPlacementSide, getPlacementStyles, isValidPlacement };

package/dist/popper.mjs

@@ -0,0 +1,5 @@
+import "./dom-query-DFCRhyj1.mjs";
+import "./utils-BZyrxWWR.mjs";
+import { i as isValidPlacement, n as getPlacement, r as getPlacementSide, t as getPlacementStyles } from "./popper-BPJeAtcA.mjs";
+
+export { getPlacement, getPlacementSide, getPlacementStyles, isValidPlacement };

package/dist/raf-BnlYUlDi.d.mts

@@ -0,0 +1,15 @@
+//#region src/shared/dom-query/raf.d.ts
+declare class AnimationFrame {
+  static create(): AnimationFrame;
+  private id;
+  private fn_cleanup;
+  request(fn?: VoidFunction | (() => VoidFunction)): void;
+  cancel(): void;
+  isActive(): boolean;
+  cleanup: () => void;
+}
+declare function raf(fn: VoidFunction | (() => VoidFunction)): () => void;
+declare function nextTick(fn: VoidFunction): () => void;
+declare function queueBeforeEvent(el: EventTarget, type: string, cb: () => void): () => void;
+//#endregion
+export { raf as i, nextTick as n, queueBeforeEvent as r, AnimationFrame as t };

package/dist/raf-Cd2FGy0z.d.cts

@@ -0,0 +1,15 @@
+//#region src/shared/dom-query/raf.d.ts
+declare class AnimationFrame {
+  static create(): AnimationFrame;
+  private id;
+  private fn_cleanup;
+  request(fn?: VoidFunction | (() => VoidFunction)): void;
+  cancel(): void;
+  isActive(): boolean;
+  cleanup: () => void;
+}
+declare function raf(fn: VoidFunction | (() => VoidFunction)): () => void;
+declare function nextTick(fn: VoidFunction): () => void;
+declare function queueBeforeEvent(el: EventTarget, type: string, cb: () => void): () => void;
+//#endregion
+export { raf as i, nextTick as n, queueBeforeEvent as r, AnimationFrame as t };