@neut/ui 0.0.1

package/dist/components/toast/hooks/useToastHeight.js

@@ -0,0 +1,33 @@
+import { createEffect as e, createSignal as t, onCleanup as n } from "solid-js";
+//#region src/components/toast/hooks/useToastHeight.ts
+function r(r) {
+	let [i, a] = t(0), o = r.toast();
+	return e(() => {
+		let e = r.toastRef();
+		if (!e) return;
+		let t = e.getBoundingClientRect().height;
+		a(t), r.setHeights((e) => [{
+			toastId: o.id,
+			height: t,
+			position: o.position
+		}, ...e]), n(() => r.setHeights((e) => e.filter((e) => e.toastId !== o.id)));
+	}), e(() => {
+		if (!r.mounted()) return;
+		let e = r.toastRef();
+		if (!e) return;
+		o.title, o.description, o.jsx, o.action, o.cancel;
+		let t = e.style.height;
+		e.style.height = "auto";
+		let n = e.getBoundingClientRect().height;
+		e.style.height = t, a(n), r.setHeights((e) => e.find((e) => e.toastId === o.id) ? e.map((e) => e.toastId === o.id ? {
+			...e,
+			height: n
+		} : e) : [{
+			toastId: o.id,
+			height: n,
+			position: o.position
+		}, ...e]);
+	}), { initialHeight: i };
+}
+//#endregion
+export { r as useToastHeight };

package/dist/components/toast/hooks/useToastSubscription.d.ts

@@ -0,0 +1,5 @@
+import { ToastT } from '../types';
+export declare function useToastSubscription(): {
+    toasts: import('solid-js').Accessor<ToastT[]>;
+    removeToast: (toast: ToastT) => void;
+};

package/dist/components/toast/hooks/useToastSubscription.js

@@ -0,0 +1,35 @@
+import { ToastState as e } from "../state.js";
+import { createSignal as t, onCleanup as n, onMount as r } from "solid-js";
+//#region src/components/toast/hooks/useToastSubscription.ts
+function i() {
+	let [i, a] = t([]);
+	return r(() => {
+		n(e.subscribe((e) => {
+			if (e.dismiss) {
+				a((t) => t.map((t) => t.id === e.id ? {
+					...t,
+					delete: !0
+				} : t));
+				return;
+			}
+			a((t) => {
+				let n = t.findIndex((t) => t.id === e.id);
+				return n === -1 ? [e, ...t] : [
+					...t.slice(0, n),
+					{
+						...t[n],
+						...e
+					},
+					...t.slice(n + 1)
+				];
+			});
+		}));
+	}), {
+		toasts: i,
+		removeToast: (t) => {
+			t.delete || e.dismiss(t.id), a((e) => e.filter((e) => e.id !== t.id));
+		}
+	};
+}
+//#endregion
+export { i as useToastSubscription };

package/dist/components/toast/hooks/useToastTimer.d.ts

@@ -0,0 +1,11 @@
+import { ToastT } from '../types';
+interface UseToastTimerOptions {
+    toast: ToastT;
+    duration: number;
+    expanded: () => boolean;
+    interacting: () => boolean;
+    isDocumentHidden: () => boolean;
+    deleteToast: () => void;
+}
+export declare function useToastTimer(opts: UseToastTimerOptions): void;
+export {};

package/dist/components/toast/hooks/useToastTimer.js

@@ -0,0 +1,20 @@
+import { createEffect as e, onCleanup as t } from "solid-js";
+//#region src/components/toast/hooks/useToastTimer.ts
+function n(n) {
+	let r = n.toast.duration ?? n.duration, i = 0, a = 0, o, s = () => n.toast.promise && n.toast.type === "loading" || n.toast.duration === Infinity || n.toast.type === "loading", c = () => {
+		if (a < i) {
+			let e = Date.now() - i;
+			r = Math.max(0, r - e);
+		}
+		a = Date.now();
+	}, l = () => {
+		r !== Infinity && (clearTimeout(o), i = Date.now(), o = setTimeout(() => {
+			n.toast.onAutoClose?.(n.toast), n.deleteToast();
+		}, r));
+	};
+	e(() => {
+		s() || (n.expanded() || n.interacting() || n.isDocumentHidden() ? c() : l(), t(() => clearTimeout(o)));
+	});
+}
+//#endregion
+export { n as useToastTimer };

package/dist/components/toast/hooks/useToasterKeyboard.d.ts

@@ -0,0 +1,7 @@
+interface UseToasterKeyboardOptions {
+    hotkey: string[];
+    listRef: () => HTMLOListElement | undefined;
+    setExpanded: (v: boolean) => void;
+}
+export declare function useToasterKeyboard(opts: UseToasterKeyboardOptions): void;
+export {};

package/dist/components/toast/hooks/useToasterKeyboard.js

@@ -0,0 +1,12 @@
+import { onCleanup as e, onMount as t } from "solid-js";
+//#region src/components/toast/hooks/useToasterKeyboard.ts
+function n(n) {
+	t(() => {
+		let t = (e) => {
+			n.hotkey.length > 0 && n.hotkey.every((t) => e[t] || e.code === t) && (n.setExpanded(!0), n.listRef()?.focus()), e.code === "Escape" && (document.activeElement === n.listRef() || n.listRef()?.contains(document.activeElement)) && n.setExpanded(!1);
+		};
+		document.addEventListener("keydown", t), e(() => document.removeEventListener("keydown", t));
+	});
+}
+//#endregion
+export { n as useToasterKeyboard };

package/dist/components/toast/hooks.d.ts

@@ -0,0 +1,13 @@
+import { ToastT } from './types';
+/**
+ * Returns a reactive boolean that tracks whether the browser tab is hidden.
+ * Used to pause auto-dismiss timers while the user has switched tabs.
+ */
+export declare function useIsDocumentHidden(): import('solid-js').Accessor<boolean>;
+/**
+ * Subscribes to the global ToastState and returns the list of currently visible
+ * toasts as a SolidJS signal. Useful for building custom toast UIs.
+ */
+export declare function useSonner(): {
+    toasts: import('solid-js').Accessor<ToastT[]>;
+};

package/dist/components/toast/hooks.js

@@ -0,0 +1,34 @@
+import { ToastState as e } from "./state.js";
+import { createSignal as t, onCleanup as n, onMount as r } from "solid-js";
+//#region src/components/toast/hooks.ts
+function i() {
+	let [e, i] = t(document.hidden);
+	return r(() => {
+		let e = () => i(document.hidden);
+		document.addEventListener("visibilitychange", e), n(() => document.removeEventListener("visibilitychange", e));
+	}), e;
+}
+function a() {
+	let [i, a] = t([]);
+	return r(() => {
+		n(e.subscribe((e) => {
+			if (e.dismiss) {
+				a((t) => t.filter((t) => t.id !== e.id));
+				return;
+			}
+			a((t) => {
+				let n = t.findIndex((t) => t.id === e.id);
+				return n === -1 ? [e, ...t] : [
+					...t.slice(0, n),
+					{
+						...t[n],
+						...e
+					},
+					...t.slice(n + 1)
+				];
+			});
+		}));
+	}), { toasts: i };
+}
+//#endregion
+export { i as useIsDocumentHidden, a as useSonner };

package/dist/components/toast/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * index.ts
+ * Public API surface — only re-exports what consumers need.
+ * Internal modules (hooks, utils, constants) are intentionally not re-exported.
+ */
+export { toast } from './state';
+export { Toaster } from './components/Toaster';
+export { Toast } from './components/Toast';
+export { useSonner } from './hooks';
+export type { Action, ExternalToast, ToasterProps, ToastClassnames, ToastT, ToastToDismiss, } from './types';

package/dist/components/toast/state.d.ts

@@ -0,0 +1,52 @@
+import { JSXElement } from 'solid-js';
+import { ExternalToast, PromiseData, PromiseT, ToastT, ToastToDismiss, ToastTypes } from './types';
+declare class Observer {
+    subscribers: Array<(toast: ToastT | ToastToDismiss) => void>;
+    toasts: Array<ToastT | ToastToDismiss>;
+    dismissedToasts: Set<string>;
+    subscribe: (subscriber: (toast: ToastT | ToastToDismiss) => void) => () => void;
+    publish: (data: ToastT) => void;
+    addToast: (data: ToastT) => void;
+    create: (data: ExternalToast & {
+        message?: JSXElement;
+        type?: ToastTypes;
+        promise?: PromiseT;
+        jsx?: (() => JSXElement) | JSXElement;
+    }) => string;
+    dismiss: (id?: string) => string | undefined;
+    message: (message: JSXElement, data?: ExternalToast) => string;
+    error: (message: JSXElement, data?: ExternalToast) => string;
+    success: (message: JSXElement, data?: ExternalToast) => string;
+    info: (message: JSXElement, data?: ExternalToast) => string;
+    warning: (message: JSXElement, data?: ExternalToast) => string;
+    loading: (message: JSXElement, data?: ExternalToast) => string;
+    promise: <ToastData>(promise: PromiseT<ToastData>, data?: PromiseData<ToastData>) => (string & {
+        unwrap: () => Promise<ToastData>;
+    }) | {
+        unwrap: () => Promise<ToastData>;
+    } | undefined;
+    custom: (jsx: (id: number | string) => any, data?: ExternalToast) => string;
+    getActiveToasts: () => (ToastT | ToastToDismiss)[];
+}
+export declare const ToastState: Observer;
+export declare const getHistory: () => (ToastT | ToastToDismiss)[];
+export declare const getToasts: () => (ToastT | ToastToDismiss)[];
+export declare const toast: ((message: JSXElement, data?: ExternalToast) => string) & {
+    success: (message: JSXElement, data?: ExternalToast) => string;
+    info: (message: JSXElement, data?: ExternalToast) => string;
+    warning: (message: JSXElement, data?: ExternalToast) => string;
+    error: (message: JSXElement, data?: ExternalToast) => string;
+    custom: (jsx: (id: number | string) => any, data?: ExternalToast) => string;
+    message: (message: JSXElement, data?: ExternalToast) => string;
+    promise: <ToastData>(promise: PromiseT<ToastData>, data?: PromiseData<ToastData> | undefined) => (string & {
+        unwrap: () => Promise<ToastData>;
+    }) | {
+        unwrap: () => Promise<ToastData>;
+    } | undefined;
+    dismiss: (id?: string) => string | undefined;
+    loading: (message: JSXElement, data?: ExternalToast) => string;
+} & {
+    getHistory: () => (ToastT | ToastToDismiss)[];
+    getToasts: () => (ToastT | ToastToDismiss)[];
+};
+export {};

package/dist/components/toast/state.js

@@ -0,0 +1,168 @@
+import { createUniqueId as e } from "solid-js";
+//#region src/components/toast/state.ts
+var t = (e) => !("id" in e && "message" in e), n = new class {
+	subscribers = [];
+	toasts = [];
+	dismissedToasts = /* @__PURE__ */ new Set();
+	subscribe = (e) => (this.subscribers.push(e), () => {
+		let t = this.subscribers.indexOf(e);
+		this.subscribers.splice(t, 1);
+	});
+	publish = (e) => {
+		for (let t of this.subscribers) t(e);
+	};
+	addToast = (e) => {
+		this.publish(e), this.toasts = [...this.toasts, e];
+	};
+	create = (t) => {
+		let { message: n, ...r } = t, i = typeof t?.id == "number" || t.id?.length > 0 ? t.id : e(), a = this.toasts.find((e) => e.id === i), o = t.dismissible === void 0 ? !0 : t.dismissible;
+		return this.dismissedToasts.has(i) && this.dismissedToasts.delete(i), a ? this.toasts = this.toasts.map((e) => e.id === i ? (this.publish({
+			...e,
+			...t,
+			id: i,
+			title: n
+		}), {
+			...e,
+			...t,
+			id: i,
+			dismissible: o,
+			title: n
+		}) : e) : this.addToast({
+			title: n,
+			...r,
+			dismissible: o,
+			id: i
+		}), i;
+	};
+	dismiss = (e) => (e === void 0 ? requestAnimationFrame(() => {
+		for (let e of this.toasts) for (let t of this.subscribers) t({
+			id: e.id,
+			dismiss: !0
+		});
+	}) : (this.dismissedToasts.add(e), requestAnimationFrame(() => {
+		for (let t of this.subscribers) t({
+			id: e,
+			dismiss: !0
+		});
+	})), e);
+	message = (e, t) => this.create({
+		...t,
+		message: e
+	});
+	error = (e, t) => this.create({
+		...t,
+		message: e,
+		type: "error"
+	});
+	success = (e, t) => this.create({
+		...t,
+		type: "success",
+		message: e
+	});
+	info = (e, t) => this.create({
+		...t,
+		type: "info",
+		message: e
+	});
+	warning = (e, t) => this.create({
+		...t,
+		type: "warning",
+		message: e
+	});
+	loading = (e, t) => this.create({
+		...t,
+		type: "loading",
+		message: e
+	});
+	promise = (e, n) => {
+		if (!n) return;
+		let r;
+		n.loading !== void 0 && (r = this.create({
+			...n,
+			promise: e,
+			type: "loading",
+			message: n.loading,
+			description: typeof n.description == "function" ? void 0 : n.description
+		}));
+		let a = Promise.resolve(e instanceof Function ? e() : e), o = r !== void 0, s, c = a.then(async (e) => {
+			if (s = ["resolve", e], t(e)) o = !1, this.create({
+				id: r,
+				type: "default",
+				message: e
+			});
+			else if (i(e) && !e.ok) {
+				o = !1;
+				let i = `HTTP error! status: ${e.status}`, a = typeof n.error == "function" ? await n.error(i) : n.error, s = typeof n.description == "function" ? await n.description(i) : n.description, c = typeof a == "object" && !t(a) ? a : { message: a };
+				this.create({
+					id: r,
+					type: "error",
+					description: s,
+					...c
+				});
+			} else if (e instanceof Error) {
+				o = !1;
+				let i = typeof n.error == "function" ? await n.error(e) : n.error, a = typeof n.description == "function" ? await n.description(e) : n.description, s = typeof i == "object" && !t(i) ? i : { message: i };
+				this.create({
+					id: r,
+					type: "error",
+					description: a,
+					...s
+				});
+			} else if (n.success !== void 0) {
+				o = !1;
+				let i = typeof n.success == "function" ? await n.success(e) : n.success, a = typeof n.description == "function" ? await n.description(e) : n.description, s = typeof i == "object" && !t(i) ? i : { message: i };
+				this.create({
+					id: r,
+					type: "success",
+					description: a,
+					...s
+				});
+			}
+		}).catch(async (e) => {
+			if (s = ["reject", e], n.error !== void 0) {
+				o = !1;
+				let i = typeof n.error == "function" ? await n.error(e) : n.error, a = typeof n.description == "function" ? await n.description(e) : n.description, s = typeof i == "object" && !t(i) ? i : { message: i };
+				this.create({
+					id: r,
+					type: "error",
+					description: a,
+					...s
+				});
+			}
+		}).finally(() => {
+			o && (this.dismiss(r), r = void 0), n.finally?.();
+		}), l = () => new Promise((e, t) => c.then(() => s[0] === "reject" ? t(s[1]) : e(s[1])).catch(t));
+		return typeof r != "string" && typeof r != "number" ? { unwrap: l } : Object.assign(r, { unwrap: l });
+	};
+	custom = (t, n) => {
+		let r = n?.id || e();
+		return this.create({
+			jsx: t(r),
+			...n,
+			id: r
+		}), r;
+	};
+	getActiveToasts = () => this.toasts.filter((e) => !this.dismissedToasts.has(e.id));
+}(), r = (t, r) => {
+	let i = e();
+	return n.addToast({
+		title: t,
+		...r,
+		id: i
+	}), i;
+}, i = (e) => e && typeof e == "object" && "ok" in e && typeof e.ok == "boolean" && "status" in e && typeof e.status == "number", a = Object.assign(r, {
+	success: n.success,
+	info: n.info,
+	warning: n.warning,
+	error: n.error,
+	custom: n.custom,
+	message: n.message,
+	promise: n.promise,
+	dismiss: n.dismiss,
+	loading: n.loading
+}, {
+	getHistory: () => n.toasts,
+	getToasts: () => n.getActiveToasts()
+});
+//#endregion
+export { n as ToastState, a as toast };

package/dist/components/toast/types.d.ts

@@ -0,0 +1,168 @@
+import { JSX, JSXElement, Setter } from 'solid-js';
+export type ToastTypes = "success" | "info" | "warning" | "error" | "loading" | "default";
+export type PromiseT<Data = any> = Promise<Data> | (() => Promise<Data>);
+export interface PromiseIExtendedResult extends ExternalToast {
+    message: JSXElement;
+}
+export type PromiseTExtendedResult<Data = any> = PromiseIExtendedResult | ((data: Data) => PromiseIExtendedResult | Promise<PromiseIExtendedResult>);
+export type PromiseTResult<Data = any> = string | JSXElement | ((data: Data) => JSXElement | string | Promise<JSXElement | string>);
+export type PromiseExternalToast = Omit<ExternalToast, "description">;
+export type PromiseData<ToastData = any> = PromiseExternalToast & {
+    loading?: string | JSXElement;
+    success?: PromiseTResult<ToastData> | PromiseTExtendedResult<ToastData>;
+    error?: PromiseTResult | PromiseTExtendedResult;
+    description?: PromiseTResult;
+    finally?: () => void | Promise<void>;
+};
+export interface ToastClassnames {
+    toast?: string;
+    title?: string;
+    description?: string;
+    loader?: string;
+    cancelButton?: string;
+    actionButton?: string;
+    success?: string;
+    error?: string;
+    info?: string;
+    warning?: string;
+    loading?: string;
+    default?: string;
+    content?: string;
+    icon?: string;
+}
+export interface ToastIcons {
+    success?: JSXElement;
+    info?: JSXElement;
+    warning?: JSXElement;
+    error?: JSXElement;
+    loading?: JSXElement;
+    close?: JSXElement;
+}
+export interface Action {
+    label: JSXElement;
+    onClick: JSX.EventHandler<HTMLButtonElement, MouseEvent>;
+    actionButtonStyle?: JSX.CSSProperties;
+}
+export interface ToastT {
+    id: string;
+    toasterId?: string;
+    title?: (() => JSXElement) | JSXElement;
+    type?: ToastTypes;
+    icon?: JSXElement;
+    jsx?: JSXElement;
+    richColors?: boolean;
+    invert?: boolean;
+    closeButton?: boolean;
+    dismissible?: boolean;
+    description?: (() => JSXElement) | JSXElement;
+    duration?: number;
+    delete?: boolean;
+    action?: Action | JSXElement;
+    cancel?: Action | JSXElement;
+    onDismiss?: (toast: ToastT) => void;
+    onAutoClose?: (toast: ToastT) => void;
+    promise?: PromiseT;
+    cancelButtonStyle?: JSX.CSSProperties;
+    actionButtonStyle?: JSX.CSSProperties;
+    style?: JSX.CSSProperties;
+    unstyled?: boolean;
+    class?: string;
+    classes?: ToastClassnames;
+    descriptionClass?: string;
+    position?: Position;
+    testId?: string;
+}
+export declare const isAction: (action: Action | JSXElement) => action is Action;
+export type Position = "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center";
+export interface HeightT {
+    height: number;
+    toastId: number | string;
+    position: Position;
+}
+interface ToastOptions {
+    class?: string;
+    closeButton?: boolean;
+    descriptionClass?: string;
+    style?: JSX.CSSProperties;
+    cancelButtonStyle?: JSX.CSSProperties;
+    actionButtonStyle?: JSX.CSSProperties;
+    duration?: number;
+    unstyled?: boolean;
+    classes?: ToastClassnames;
+    closeButtonAriaLabel?: string;
+    toasterId?: string;
+}
+type Offset = {
+    top?: string | number;
+    right?: string | number;
+    bottom?: string | number;
+    left?: string | number;
+} | string | number;
+export interface ToasterProps {
+    id?: string;
+    invert?: boolean;
+    theme?: "light" | "dark" | "system";
+    position?: Position;
+    hotkey?: string[];
+    richColors?: boolean;
+    expand?: boolean;
+    duration?: number;
+    gap?: number;
+    visibleToasts?: number;
+    closeButton?: boolean;
+    toastOptions?: ToastOptions;
+    class?: string;
+    style?: JSX.CSSProperties;
+    offset?: Offset;
+    mobileOffset?: Offset;
+    dir?: "rtl" | "ltr" | "auto";
+    swipeDirections?: SwipeDirection[];
+    icons?: ToastIcons;
+    customAriaLabel?: string;
+    containerAriaLabel?: string;
+}
+export type SwipeDirection = "top" | "right" | "bottom" | "left";
+export interface ToastProps {
+    toast: ToastT;
+    toasts: ToastT[];
+    index: number;
+    swipeDirections?: SwipeDirection[];
+    expanded: boolean;
+    invert: boolean;
+    heights: HeightT[];
+    setHeights: Setter<HeightT[]>;
+    removeToast: (toast: ToastT) => void;
+    gap?: number;
+    position: Position;
+    visibleToasts: number;
+    expandByDefault: boolean;
+    closeButton: boolean;
+    interacting: boolean;
+    style?: JSX.CSSProperties;
+    cancelButtonStyle?: JSX.CSSProperties;
+    actionButtonStyle?: JSX.CSSProperties;
+    duration?: number;
+    class?: string;
+    unstyled?: boolean;
+    descriptionClass?: string;
+    loadingIcon?: JSXElement;
+    classes?: ToastClassnames;
+    icons?: ToastIcons;
+    closeButtonAriaLabel?: string;
+    defaultRichColors?: boolean;
+}
+export declare enum SwipeStateTypes {
+    SwipedOut = "SwipedOut",
+    SwipedBack = "SwipedBack",
+    NotSwiped = "NotSwiped"
+}
+export type Theme = "light" | "dark";
+export interface ToastToDismiss {
+    id: string;
+    dismiss: boolean;
+}
+export type ExternalToast = Omit<ToastT, "id" | "type" | "title" | "jsx" | "delete" | "promise"> & {
+    id?: string;
+    toasterId?: string;
+};
+export {};

package/dist/components/toast/types.js

@@ -0,0 +1,4 @@
+//#region src/components/toast/types.ts
+var e = (e) => e?.label !== void 0;
+//#endregion
+export { e as isAction };

package/dist/components/toast/utils.d.ts

@@ -0,0 +1,10 @@
+import { SwipeDirection, ToasterProps } from './types';
+/** Derives default swipe directions from a position string like "bottom-right" */
+export declare function getDefaultSwipeDirections(position: string): SwipeDirection[];
+/** Reads the document text direction (for RTL support) */
+export declare function getDocumentDirection(): ToasterProps["dir"];
+/**
+ * Converts offset prop (string | number | object) into CSS custom property map.
+ * Produces both desktop (`--offset-*`) and mobile (`--mobile-offset-*`) vars.
+ */
+export declare function assignOffset(defaultOffset: ToasterProps["offset"], mobileOffset: ToasterProps["mobileOffset"]): Record<string, string>;

package/dist/components/toast/utils.js

@@ -0,0 +1,37 @@
+import { MOBILE_VIEWPORT_OFFSET as e, VIEWPORT_OFFSET as t } from "./constants.js";
+//#region src/components/toast/utils.ts
+function n(e) {
+	let [t, n] = e.split("-"), r = [];
+	return t && r.push(t), n && r.push(n), r;
+}
+function r() {
+	if (typeof window > "u" || typeof document > "u") return "ltr";
+	let e = document.documentElement.getAttribute("dir");
+	return e === "auto" || !e ? window.getComputedStyle(document.documentElement).direction : e;
+}
+function i(n, r) {
+	let i = {};
+	return [n, r].forEach((n, r) => {
+		let a = r === 1, o = a ? "--mobile-offset" : "--offset", s = a ? e : t, c = (e) => {
+			[
+				"top",
+				"right",
+				"bottom",
+				"left"
+			].forEach((t) => {
+				i[`${o}-${t}`] = typeof e == "number" ? `${e}px` : e;
+			});
+		};
+		typeof n == "number" || typeof n == "string" ? c(n) : typeof n == "object" && n ? [
+			"top",
+			"right",
+			"bottom",
+			"left"
+		].forEach((e) => {
+			let t = n[e];
+			i[`${o}-${e}`] = t === void 0 ? s : typeof t == "number" ? `${t}px` : t;
+		}) : c(s);
+	}), i;
+}
+//#endregion
+export { i as assignOffset, n as getDefaultSwipeDirections, r as getDocumentDirection };

package/dist/components/tooltip/Tooltip/Tooltip.context.d.ts

@@ -0,0 +1,12 @@
+type TooltipContextValue = {
+    open: () => boolean;
+    setOpen: (v: boolean) => void;
+    triggerRef: () => HTMLElement | undefined;
+    setTriggerRef: (el: HTMLElement) => void;
+    contentId: string;
+    openDelay: number;
+    closeDelay: number;
+};
+export declare const TooltipContext: import('solid-js').Context<TooltipContextValue | undefined>;
+export declare function useTooltipContext(): TooltipContextValue;
+export {};

package/dist/components/tooltip/Tooltip/Tooltip.context.js

@@ -0,0 +1,10 @@
+import { createContext as e, useContext as t } from "solid-js";
+//#region src/components/tooltip/Tooltip/Tooltip.context.ts
+var n = e();
+function r() {
+	let e = t(n);
+	if (!e) throw Error("Tooltip components must be used within Tooltip.Root");
+	return e;
+}
+//#endregion
+export { n as TooltipContext, r as useTooltipContext };

package/dist/components/tooltip/Tooltip/Tooltip.d.ts

@@ -0,0 +1,5 @@
+import { ParentProps } from 'solid-js';
+export declare const Tooltip: (props: ParentProps & {
+    openDelay?: number;
+    closeDelay?: number;
+}) => import("solid-js").JSX.Element;