@alivault/pico 0.1.0

package/.output/server/_libs/@radix-ui/react-primitive+[...].mjs

@@ -0,0 +1,136 @@
+import { i as __toESM } from "../../_runtime.mjs";
+import { X as require_react, Y as require_jsx_runtime, q as require_react_dom } from "../@base-ui/react+[...].mjs";
+import { t as composeRefs } from "../radix-ui__react-compose-refs.mjs";
+require_react_dom();
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var import_jsx_runtime = require_jsx_runtime();
+var REACT_LAZY_TYPE = Symbol.for("react.lazy");
+var use = import_react[" use ".trim().toString()];
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value;
+}
+function isLazyComponent(element) {
+	return element != null && typeof element === "object" && "$$typeof" in element && element.$$typeof === REACT_LAZY_TYPE && "_payload" in element && isPromiseLike(element._payload);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function createSlot(ownerName) {
+	const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
+	const Slot2 = import_react.forwardRef((props, forwardedRef) => {
+		let { children, ...slotProps } = props;
+		if (isLazyComponent(children) && typeof use === "function") children = use(children._payload);
+		const childrenArray = import_react.Children.toArray(children);
+		const slottable = childrenArray.find(isSlottable);
+		if (slottable) {
+			const newElement = slottable.props.children;
+			const newChildren = childrenArray.map((child) => {
+				if (child === slottable) {
+					if (import_react.Children.count(newElement) > 1) return import_react.Children.only(null);
+					return import_react.isValidElement(newElement) ? newElement.props.children : null;
+				} else return child;
+			});
+			return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SlotClone, {
+				...slotProps,
+				ref: forwardedRef,
+				children: import_react.isValidElement(newElement) ? import_react.cloneElement(newElement, void 0, newChildren) : null
+			});
+		}
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SlotClone, {
+			...slotProps,
+			ref: forwardedRef,
+			children
+		});
+	});
+	Slot2.displayName = `${ownerName}.Slot`;
+	return Slot2;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function createSlotClone(ownerName) {
+	const SlotClone = import_react.forwardRef((props, forwardedRef) => {
+		let { children, ...slotProps } = props;
+		if (isLazyComponent(children) && typeof use === "function") children = use(children._payload);
+		if (import_react.isValidElement(children)) {
+			const childrenRef = getElementRef(children);
+			const props2 = mergeProps(slotProps, children.props);
+			if (children.type !== import_react.Fragment) props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;
+			return import_react.cloneElement(children, props2);
+		}
+		return import_react.Children.count(children) > 1 ? import_react.Children.only(null) : null;
+	});
+	SlotClone.displayName = `${ownerName}.SlotClone`;
+	return SlotClone;
+}
+var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+function isSlottable(child) {
+	return import_react.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+}
+function mergeProps(slotProps, childProps) {
+	const overrideProps = { ...childProps };
+	for (const propName in childProps) {
+		const slotPropValue = slotProps[propName];
+		const childPropValue = childProps[propName];
+		if (/^on[A-Z]/.test(propName)) {
+			if (slotPropValue && childPropValue) overrideProps[propName] = (...args) => {
+				const result = childPropValue(...args);
+				slotPropValue(...args);
+				return result;
+			};
+			else if (slotPropValue) overrideProps[propName] = slotPropValue;
+		} else if (propName === "style") overrideProps[propName] = {
+			...slotPropValue,
+			...childPropValue
+		};
+		else if (propName === "className") overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+	}
+	return {
+		...slotProps,
+		...overrideProps
+	};
+}
+function getElementRef(element) {
+	let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+	let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.ref;
+	getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+	mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.props.ref;
+	return element.props.ref || element.ref;
+}
+//#endregion
+//#region node_modules/.pnpm/@radix-ui+react-primitive@2.1.4_@types+react-dom@19.2.3_@types+react@19.2.14__@types+re_96f4d954bf36efe7aac76e082e992298/node_modules/@radix-ui/react-primitive/dist/index.mjs
+var Primitive = [
+	"a",
+	"button",
+	"div",
+	"form",
+	"h2",
+	"h3",
+	"img",
+	"input",
+	"label",
+	"li",
+	"nav",
+	"ol",
+	"p",
+	"select",
+	"span",
+	"svg",
+	"ul"
+].reduce((primitive, node) => {
+	const Slot = /* @__PURE__ */ createSlot(`Primitive.${node}`);
+	const Node = import_react.forwardRef((props, forwardedRef) => {
+		const { asChild, ...primitiveProps } = props;
+		const Comp = asChild ? Slot : node;
+		if (typeof window !== "undefined") window[Symbol.for("radix-ui")] = true;
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Comp, {
+			...primitiveProps,
+			ref: forwardedRef
+		});
+	});
+	Node.displayName = `Primitive.${node}`;
+	return {
+		...primitive,
+		[node]: Node
+	};
+}, {});
+//#endregion
+export { Primitive as t };

package/.output/server/_libs/@tanstack/devtools-event-client+[...].mjs

@@ -0,0 +1,196 @@
+//#region node_modules/.pnpm/@tanstack+devtools-event-client@0.4.3/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.js
+var EventClient = class {
+	#enabled = true;
+	#pluginId;
+	#eventTarget;
+	#debug;
+	#queuedEvents;
+	#connected;
+	#connectIntervalId;
+	#connectEveryMs;
+	#retryCount = 0;
+	#maxRetries = 5;
+	#connecting = false;
+	#failedToConnect = false;
+	#internalEventTarget = null;
+	#onConnected = () => {
+		this.debugLog("Connected to event bus");
+		this.#connected = true;
+		this.#connecting = false;
+		this.debugLog("Emitting queued events", this.#queuedEvents);
+		this.#queuedEvents.forEach((event) => this.emitEventToBus(event));
+		this.#queuedEvents = [];
+		this.stopConnectLoop();
+		this.#eventTarget().removeEventListener("tanstack-connect-success", this.#onConnected);
+	};
+	#retryConnection = () => {
+		if (this.#retryCount < this.#maxRetries) {
+			this.#retryCount++;
+			this.dispatchCustomEvent("tanstack-connect", {});
+			return;
+		}
+		this.#eventTarget().removeEventListener("tanstack-connect", this.#retryConnection);
+		this.#failedToConnect = true;
+		this.debugLog("Max retries reached, giving up on connection");
+		this.stopConnectLoop();
+	};
+	#connectFunction = () => {
+		if (this.#connecting) return;
+		this.#connecting = true;
+		this.#eventTarget().addEventListener("tanstack-connect-success", this.#onConnected);
+		this.#retryConnection();
+	};
+	constructor({ pluginId, debug = false, enabled = true, reconnectEveryMs = 300 }) {
+		this.#pluginId = pluginId;
+		this.#enabled = enabled;
+		this.#eventTarget = this.getGlobalTarget;
+		this.#debug = debug;
+		this.debugLog(" Initializing event subscription for plugin", this.#pluginId);
+		this.#queuedEvents = [];
+		this.#connected = false;
+		this.#failedToConnect = false;
+		this.#connectIntervalId = null;
+		this.#connectEveryMs = reconnectEveryMs;
+	}
+	startConnectLoop() {
+		if (this.#connectIntervalId !== null || this.#connected) return;
+		this.debugLog(`Starting connect loop (every ${this.#connectEveryMs}ms)`);
+		this.#connectIntervalId = setInterval(this.#retryConnection, this.#connectEveryMs);
+	}
+	stopConnectLoop() {
+		this.#connecting = false;
+		if (this.#connectIntervalId === null) return;
+		clearInterval(this.#connectIntervalId);
+		this.#connectIntervalId = null;
+		this.#queuedEvents = [];
+		this.debugLog("Stopped connect loop");
+	}
+	debugLog(...args) {
+		if (this.#debug) console.log(`🌴 [tanstack-devtools:${this.#pluginId}-plugin]`, ...args);
+	}
+	getGlobalTarget() {
+		if (typeof globalThis !== "undefined" && globalThis.__TANSTACK_EVENT_TARGET__) {
+			this.debugLog("Using global event target");
+			return globalThis.__TANSTACK_EVENT_TARGET__;
+		}
+		if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+			this.debugLog("Using window as event target");
+			return window;
+		}
+		const eventTarget = typeof EventTarget !== "undefined" ? new EventTarget() : void 0;
+		if (typeof eventTarget === "undefined" || typeof eventTarget.addEventListener === "undefined") {
+			this.debugLog("No event mechanism available, running in non-web environment");
+			return {
+				addEventListener: () => {},
+				removeEventListener: () => {},
+				dispatchEvent: () => false
+			};
+		}
+		this.debugLog("Using new EventTarget as fallback");
+		return eventTarget;
+	}
+	getPluginId() {
+		return this.#pluginId;
+	}
+	dispatchCustomEventShim(eventName, detail) {
+		try {
+			const event = new Event(eventName, { detail });
+			this.#eventTarget().dispatchEvent(event);
+		} catch (e) {
+			this.debugLog("Failed to dispatch shim event");
+		}
+	}
+	dispatchCustomEvent(eventName, detail) {
+		try {
+			this.#eventTarget().dispatchEvent(new CustomEvent(eventName, { detail }));
+		} catch (e) {
+			this.dispatchCustomEventShim(eventName, detail);
+		}
+	}
+	emitEventToBus(event) {
+		this.debugLog("Emitting event to client bus", event);
+		this.dispatchCustomEvent("tanstack-dispatch-event", event);
+	}
+	createEventPayload(eventSuffix, payload) {
+		return {
+			type: `${this.#pluginId}:${eventSuffix}`,
+			payload,
+			pluginId: this.#pluginId
+		};
+	}
+	emit(eventSuffix, payload) {
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not emitting event", eventSuffix, payload);
+			return;
+		}
+		if (this.#internalEventTarget) {
+			this.debugLog("Emitting event to internal event target", eventSuffix, payload);
+			this.#internalEventTarget.dispatchEvent(new CustomEvent(`${this.#pluginId}:${eventSuffix}`, { detail: this.createEventPayload(eventSuffix, payload) }));
+		}
+		if (this.#failedToConnect) {
+			this.debugLog("Previously failed to connect, not emitting to bus");
+			return;
+		}
+		if (!this.#connected) {
+			this.debugLog("Bus not available, will be pushed as soon as connected");
+			this.#queuedEvents.push(this.createEventPayload(eventSuffix, payload));
+			if (typeof CustomEvent !== "undefined" && !this.#connecting) {
+				this.#connectFunction();
+				this.startConnectLoop();
+			}
+			return;
+		}
+		return this.emitEventToBus(this.createEventPayload(eventSuffix, payload));
+	}
+	on(eventSuffix, cb, options) {
+		const withEventTarget = options?.withEventTarget ?? false;
+		const eventName = `${this.#pluginId}:${eventSuffix}`;
+		if (withEventTarget) {
+			if (!this.#internalEventTarget) this.#internalEventTarget = new EventTarget();
+			this.#internalEventTarget.addEventListener(eventName, (e) => {
+				cb(e.detail);
+			});
+		}
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not registering event", eventName);
+			return () => {};
+		}
+		const handler = (e) => {
+			this.debugLog("Received event from bus", e.detail);
+			cb(e.detail);
+		};
+		this.#eventTarget().addEventListener(eventName, handler);
+		this.debugLog("Registered event to bus", eventName);
+		return () => {
+			if (withEventTarget) this.#internalEventTarget?.removeEventListener(eventName, handler);
+			this.#eventTarget().removeEventListener(eventName, handler);
+		};
+	}
+	onAll(cb) {
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not registering event");
+			return () => {};
+		}
+		const handler = (e) => {
+			const event = e.detail;
+			cb(event);
+		};
+		this.#eventTarget().addEventListener("tanstack-devtools-global", handler);
+		return () => this.#eventTarget().removeEventListener("tanstack-devtools-global", handler);
+	}
+	onAllPluginEvents(cb) {
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not registering event");
+			return () => {};
+		}
+		const handler = (e) => {
+			const event = e.detail;
+			if (this.#pluginId && event.pluginId !== this.#pluginId) return;
+			cb(event);
+		};
+		this.#eventTarget().addEventListener("tanstack-devtools-global", handler);
+		return () => this.#eventTarget().removeEventListener("tanstack-devtools-global", handler);
+	}
+};
+//#endregion
+export { EventClient as t };