@vizejs/composable 0.426.3 → 0.427.0

package/dist/use-drop-zone.mjs

@@ -0,0 +1,154 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { readonly, ref, shallowRef, toValue, unref, watch } from "vue";
+//#region src/use-drop-zone.ts
+function matchesPattern(pattern, file) {
+	const normalized = pattern.trim().toLowerCase();
+	if (normalized === "" || normalized === "*" || normalized === "*/*") return true;
+	if (normalized.startsWith(".")) return file.name === "" || file.name.toLowerCase().endsWith(normalized);
+	const type = file.type.toLowerCase();
+	if (normalized.endsWith("/*")) return type.startsWith(normalized.slice(0, -1));
+	return type === normalized;
+}
+/**
+* Test a file against `accept`-attribute style patterns.
+*
+* Supports exact MIME types, wildcard subtypes (`"image/*"`), extensions
+* (`".png"`, case-insensitive), and `"*"`. An empty pattern list accepts
+* everything. An empty `name` (the file is still being dragged) makes
+* extension patterns match provisionally.
+*
+* @param accept Patterns to test.
+* @param file File name and MIME type.
+* @returns Whether any pattern matches.
+*/
+function matchesAccept(accept, file) {
+	return accept.length === 0 || accept.some((pattern) => matchesPattern(pattern, file));
+}
+function dataTransferOf(event) {
+	if (!("dataTransfer" in event)) return void 0;
+	const transfer = event.dataTransfer;
+	if (typeof transfer !== "object" || transfer === null || !("files" in transfer)) return void 0;
+	return isDataTransfer(transfer) ? transfer : void 0;
+}
+function isDataTransfer(candidate) {
+	return "files" in candidate && "dropEffect" in candidate;
+}
+function draggedTypes(transfer) {
+	const types = [];
+	const items = transfer.items;
+	if (!items) return types;
+	for (let index = 0; index < items.length; index += 1) {
+		const item = items[index];
+		if (item?.kind === "file") types.push(item.type);
+	}
+	return types;
+}
+/**
+* Headless drop-zone logic for any element.
+*
+* Tracks whether a drag is over the target (a nesting counter keeps
+* `dragleave` from child elements from flickering the state), decides
+* acceptance from the dragged MIME types while dragging, and filters the
+* dropped files by `accept` (including extension patterns) and `multiple`.
+* Rejected drags show the `"none"` drop effect. Rendering is entirely up to
+* the caller. Listeners follow the reactive target and are removed when the
+* owning reactive scope stops.
+*
+* Server rendering: no listener is attached; all state is empty/false.
+*
+* @example
+* ```ts
+* const zone = useTemplateRef<HTMLElement>("zone");
+* const { isOverDropZone, files } = useDropZone(zone, { accept: ["image/*"] });
+* ```
+*
+* @param target Reactive drop target.
+* @param options Acceptance rules and lifecycle callbacks.
+* @default options {}
+* @returns Drag and drop state.
+*/
+function useDropZone(target, options = {}) {
+	const isOverDropZone = ref(false);
+	const accepted = ref(false);
+	const files = shallowRef(null);
+	let depth = 0;
+	const acceptsTypes = (types) => {
+		const accept = unref(options.accept);
+		if (types.length === 0) return false;
+		if (!(toValue(options.multiple) ?? true) && types.length > 1) return false;
+		if (accept === void 0) return true;
+		if (typeof accept === "function") return accept(types);
+		return types.every((type) => matchesAccept(accept, {
+			name: "",
+			type
+		}));
+	};
+	const acceptedFiles = (transfer) => {
+		const dropped = Array.from(transfer.files);
+		const accept = unref(options.accept);
+		const matching = accept === void 0 ? dropped : typeof accept === "function" ? accept(dropped.map((file) => file.type)) ? dropped : [] : dropped.filter((file) => matchesAccept(accept, file));
+		if (matching.length !== dropped.length) return [];
+		return !(toValue(options.multiple) ?? true) && matching.length > 1 ? [] : matching;
+	};
+	const settleDefault = (event, transfer) => {
+		if (accepted.value || (options.preventDefaultForUnhandled ?? false)) event.preventDefault();
+		if (transfer) transfer.dropEffect = accepted.value ? "copy" : "none";
+	};
+	const onEnter = (event) => {
+		const transfer = dataTransferOf(event);
+		depth += 1;
+		if (depth === 1) {
+			accepted.value = transfer !== void 0 && acceptsTypes(draggedTypes(transfer));
+			isOverDropZone.value = true;
+			options.onEnter?.(event);
+		}
+		settleDefault(event, transfer);
+	};
+	const onOver = (event) => {
+		settleDefault(event, dataTransferOf(event));
+		options.onOver?.(event);
+	};
+	const onLeave = (event) => {
+		depth = Math.max(0, depth - 1);
+		if (depth > 0) return;
+		isOverDropZone.value = false;
+		accepted.value = false;
+		options.onLeave?.(event);
+	};
+	const onDrop = (event) => {
+		const transfer = dataTransferOf(event);
+		const dropped = transfer ? acceptedFiles(transfer) : [];
+		if (dropped.length > 0 || (options.preventDefaultForUnhandled ?? false)) event.preventDefault();
+		depth = 0;
+		isOverDropZone.value = false;
+		accepted.value = false;
+		files.value = dropped.length > 0 ? dropped : null;
+		options.onDrop?.(files.value, event);
+	};
+	tryOnScopeDispose(watch(() => toValue(target) ?? void 0, (element, _previous, onCleanup) => {
+		depth = 0;
+		isOverDropZone.value = false;
+		accepted.value = false;
+		if (!element) return;
+		element.addEventListener("dragenter", onEnter);
+		element.addEventListener("dragover", onOver);
+		element.addEventListener("dragleave", onLeave);
+		element.addEventListener("drop", onDrop);
+		onCleanup(() => {
+			element.removeEventListener("dragenter", onEnter);
+			element.removeEventListener("dragover", onOver);
+			element.removeEventListener("dragleave", onLeave);
+			element.removeEventListener("drop", onDrop);
+		});
+	}, {
+		immediate: true,
+		flush: "sync"
+	}));
+	return {
+		isOverDropZone: readonly(isOverDropZone),
+		accepted: readonly(accepted),
+		files
+	};
+}
+//#endregion
+export { matchesAccept, useDropZone };

package/dist/use-event-source.d.mts

@@ -0,0 +1,184 @@
+import { t as TimeoutScheduler } from "./timeout-scheduler-CI8RVLZs.mjs";
+import { t as RetryDelayOptions } from "./retry-delay-DYsdq4SE.mjs";
+import { MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#region src/use-event-source.d.ts
+/** Connection status exposed by {@link useEventSource}. */
+type EventSourceStatus = "connecting" | "open" | "closed";
+/** Minimal `EventSource` instance used by {@link useEventSource}. */
+interface EventSourceLike {
+  /** `0` connecting, `1` open, `2` closed (native values). */
+  readonly readyState: number;
+  /** Close the stream; the source never reconnects afterwards. */
+  close(): void;
+  /** Subscribe to `open`, `error`, or a named server event. */
+  addEventListener(type: string, listener: EventListener): void;
+  /** Remove a listener registered with `addEventListener`. */
+  removeEventListener(type: string, listener: EventListener): void;
+}
+/** Constructor creating {@link EventSourceLike} streams (e.g. `EventSource`). */
+type EventSourceConstructorLike = new (url: string, init?: {
+  readonly withCredentials?: boolean;
+}) => EventSourceLike;
+/** Server event map: event name to decoded data type. */
+type EventSourceEventMap = Record<string, unknown>;
+/** Event names of a map whose data is not plain text and therefore needs a parser. */
+type ParsedEventNames<Events extends EventSourceEventMap> = { [Name in keyof Events & string]: [string] extends [Events[Name]] ? never : Name }[keyof Events & string];
+/**
+ * Per-event decoders. A decoder is required for every event whose data type
+ * cannot hold the raw text, and optional otherwise.
+ */
+type EventSourceParsers<Events extends EventSourceEventMap> = { readonly [Name in ParsedEventNames<Events>]: (raw: string) => Events[Name] } & { readonly [Name in Exclude<keyof Events & string, ParsedEventNames<Events>>]?: (raw: string) => Events[Name] };
+/** One decoded server event, discriminated by `event`. */
+type EventSourceMessage<Events extends EventSourceEventMap> = { readonly [Name in keyof Events & string]: {
+  /** Server event name. */readonly event: Name; /** Decoded data. */
+  readonly data: Events[Name]; /** `id:` field of the event, or `""`. */
+  readonly lastEventId: string;
+} }[keyof Events & string];
+/** Discriminated failure reported by {@link useEventSource}. */
+type EventSourceFailure = {
+  /** The stream dispatched an `error` event. */readonly kind: "error"; /** The dispatched event. */
+  readonly event: Event;
+} | {
+  /** The constructor threw. */readonly kind: "connect"; /** Exact thrown value. */
+  readonly cause: unknown;
+} | {
+  /** A parser threw. */readonly kind: "parse"; /** Event whose data could not be parsed. */
+  readonly event: string; /** Exact thrown value. */
+  readonly cause: unknown;
+} | {
+  /** Automatic reconnection gave up. */readonly kind: "reconnect-exhausted"; /** Reconnection attempts performed. */
+  readonly attempts: number;
+};
+/** Options for reconnecting streams the browser gave up on. */
+interface EventSourceReconnectOptions extends RetryDelayOptions {
+  /**
+   * Maximum consecutive reconnection attempts.
+   *
+   * @default Infinity
+   */
+  readonly retries?: number;
+  /**
+   * Called once reconnection gives up.
+   *
+   * @default undefined
+   */
+  readonly onFailed?: () => void;
+}
+/** Options for {@link useEventSource}. */
+interface UseEventSourceOptions<Events extends EventSourceEventMap> {
+  /**
+   * Named server events to subscribe to.
+   *
+   * @default ["message"]
+   */
+  readonly events?: readonly (keyof Events & string)[];
+  /**
+   * Per-event decoders (required for events whose data is not text).
+   *
+   * @default raw text for every event
+   */
+  readonly parse?: EventSourceParsers<Events>;
+  /**
+   * Send cookies with cross-origin requests.
+   *
+   * @default false
+   */
+  readonly withCredentials?: boolean;
+  /**
+   * `EventSource` constructor (a plain value or ref, never a getter).
+   * Supplying one also enables automatic connection outside a browser.
+   *
+   * @default window.EventSource when a browser window exists
+   */
+  readonly host?: MaybeRef<EventSourceConstructorLike | null | undefined>;
+  /**
+   * Connect as soon as a URL is available (browser or explicit host only).
+   *
+   * @default true
+   */
+  readonly immediate?: boolean;
+  /**
+   * Reopen the stream with backoff after the browser closes it for good
+   * (native reconnection covers transient drops).
+   *
+   * @default false
+   */
+  readonly autoReconnect?: boolean | EventSourceReconnectOptions;
+  /**
+   * Timer host for reconnection.
+   *
+   * @default globalThis timer functions
+   */
+  readonly scheduler?: TimeoutScheduler;
+  /**
+   * Observe failures.
+   *
+   * @default undefined
+   */
+  readonly onError?: (failure: EventSourceFailure) => void;
+}
+/** Reactive state and controls returned by {@link useEventSource}. */
+interface EventSourceControls<Events extends EventSourceEventMap> {
+  /** Connection status. */
+  readonly status: Readonly<Ref<EventSourceStatus>>;
+  /** Latest decoded event, discriminated by name. */
+  readonly message: Readonly<ShallowRef<EventSourceMessage<Events> | undefined>>;
+  /** Data of the latest event. */
+  readonly data: Readonly<ShallowRef<Events[keyof Events & string] | undefined>>;
+  /** Name of the latest event. */
+  readonly event: Readonly<Ref<(keyof Events & string) | undefined>>;
+  /** `id:` field of the latest event. */
+  readonly lastEventId: Readonly<Ref<string | undefined>>;
+  /** Latest failure, cleared when the stream opens. */
+  readonly error: Readonly<ShallowRef<EventSourceFailure | undefined>>;
+  /** Current underlying source, if any. */
+  readonly source: Readonly<ShallowRef<EventSourceLike | undefined>>;
+  /**
+   * Observe one subscribed event with typed data.
+   *
+   * @returns A function removing the handler.
+   */
+  readonly on: <Name extends keyof Events & string>(event: Name, handler: (data: NoInfer<Events[Name]>, lastEventId: string) => void) => () => void;
+  /** Open (or reopen) the stream. */
+  readonly open: () => void;
+  /** Close the stream and disable reconnection. */
+  readonly close: () => void;
+}
+/**
+ * Required options when the event map contains non-text data: `parse` must
+ * then provide those decoders.
+ */
+type EventSourceParseRequirement<Events extends EventSourceEventMap> = [ParsedEventNames<Events>] extends [never] ? unknown : {
+  readonly parse: EventSourceParsers<Events>;
+};
+/**
+ * Reactive Server-Sent Events stream with typed, per-event decoding.
+ *
+ * Every subscribed event is decoded by its parser (raw text by default) and
+ * exposed as a discriminated `message`, plus `data`/`event`/`lastEventId`
+ * shortcuts and typed `on()` handlers. Transient drops use the browser's
+ * native reconnection; `autoReconnect` additionally reopens streams the
+ * browser closed for good. The stream and timers are released when the
+ * owning reactive scope stops (the caller owns `close()` outside a scope).
+ * Server rendering never connects and reports `"closed"`.
+ *
+ * @example
+ * ```ts
+ * const feed = useEventSource<{ price: number; notice: string }>("/stream", {
+ *   events: ["price", "notice"],
+ *   parse: { price: (raw) => Number(raw) },
+ * });
+ * feed.on("price", (price) => chart.push(price));
+ * ```
+ *
+ * @param url Reactive URL; changing it reconnects.
+ * @param options Events, decoders, host, and reconnection options.
+ * @default options {}
+ * @returns Reactive state and controls.
+ */
+declare function useEventSource<Events extends EventSourceEventMap = {
+  message: string;
+}>(url: MaybeRefOrGetter<string | URL | null | undefined>, ...[options]: unknown extends EventSourceParseRequirement<Events> ? [options?: UseEventSourceOptions<Events>] : [options: UseEventSourceOptions<Events> & EventSourceParseRequirement<Events>]): EventSourceControls<Events>;
+//#endregion
+export { EventSourceConstructorLike, EventSourceControls, EventSourceEventMap, EventSourceFailure, EventSourceLike, EventSourceMessage, EventSourceParseRequirement, EventSourceParsers, EventSourceReconnectOptions, EventSourceStatus, UseEventSourceOptions, useEventSource };

package/dist/use-event-source.mjs

@@ -0,0 +1,226 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { calculateRetryDelay } from "./retry-delay.mjs";
+import { readonly, shallowRef, toValue, unref, watch } from "vue";
+//#region src/use-event-source.ts
+const CLOSED = 2;
+function browserEventSource() {
+	return typeof window !== "undefined" && typeof window.EventSource === "function" ? window.EventSource : void 0;
+}
+function defaultScheduler() {
+	return {
+		setTimeout: (callback, delayMs) => {
+			const handle = globalThis.setTimeout(callback, delayMs);
+			return () => globalThis.clearTimeout(handle);
+		},
+		clearTimeout: (cancel) => {
+			if (typeof cancel === "function") cancel();
+		}
+	};
+}
+function eventData(value) {
+	return value;
+}
+/**
+* Reactive Server-Sent Events stream with typed, per-event decoding.
+*
+* Every subscribed event is decoded by its parser (raw text by default) and
+* exposed as a discriminated `message`, plus `data`/`event`/`lastEventId`
+* shortcuts and typed `on()` handlers. Transient drops use the browser's
+* native reconnection; `autoReconnect` additionally reopens streams the
+* browser closed for good. The stream and timers are released when the
+* owning reactive scope stops (the caller owns `close()` outside a scope).
+* Server rendering never connects and reports `"closed"`.
+*
+* @example
+* ```ts
+* const feed = useEventSource<{ price: number; notice: string }>("/stream", {
+*   events: ["price", "notice"],
+*   parse: { price: (raw) => Number(raw) },
+* });
+* feed.on("price", (price) => chart.push(price));
+* ```
+*
+* @param url Reactive URL; changing it reconnects.
+* @param options Events, decoders, host, and reconnection options.
+* @default options {}
+* @returns Reactive state and controls.
+*/
+function useEventSource(url, ...[options]) {
+	const settings = options ?? {};
+	const status = shallowRef("closed");
+	const message = shallowRef();
+	const data = shallowRef();
+	const event = shallowRef();
+	const lastEventId = shallowRef(void 0);
+	const error = shallowRef(void 0);
+	const source = shallowRef(void 0);
+	const scheduler = settings.scheduler ?? defaultScheduler();
+	const reconnect = settings.autoReconnect === true ? {} : settings.autoReconnect || void 0;
+	const handlers = /* @__PURE__ */ new Map();
+	let attempts = 0;
+	let manuallyClosed = false;
+	let reconnectTimer;
+	let detach;
+	const resolveHost = () => settings.host === void 0 ? browserEventSource() : unref(settings.host) ?? void 0;
+	const fail = (failure) => {
+		error.value = failure;
+		settings.onError?.(failure);
+	};
+	const dispose = () => {
+		detach?.();
+		detach = void 0;
+		source.value?.close();
+		source.value = void 0;
+	};
+	const scheduleReconnect = () => {
+		if (!reconnect || manuallyClosed) return;
+		if (attempts >= (reconnect.retries ?? Number.POSITIVE_INFINITY)) {
+			fail({
+				kind: "reconnect-exhausted",
+				attempts
+			});
+			reconnect.onFailed?.();
+			return;
+		}
+		attempts += 1;
+		reconnectTimer = scheduler.setTimeout(() => {
+			reconnectTimer = void 0;
+			connect();
+		}, calculateRetryDelay(attempts, reconnect));
+	};
+	const deliver = (name, raw, id) => {
+		const parser = settings.parse?.[name];
+		let decoded;
+		try {
+			decoded = eventData(parser ? parser(raw) : raw);
+		} catch (cause) {
+			fail({
+				kind: "parse",
+				event: name,
+				cause
+			});
+			return;
+		}
+		message.value = {
+			event: name,
+			data: decoded,
+			lastEventId: id
+		};
+		data.value = decoded;
+		event.value = name;
+		lastEventId.value = id;
+		for (const handler of handlers.get(name) ?? []) handler(decoded, id);
+	};
+	const connect = () => {
+		if (reconnectTimer !== void 0) {
+			scheduler.clearTimeout(reconnectTimer);
+			reconnectTimer = void 0;
+		}
+		dispose();
+		const target = toValue(url);
+		const Host = resolveHost();
+		if (target === null || target === void 0 || Host === void 0) {
+			status.value = "closed";
+			return;
+		}
+		let instance;
+		try {
+			instance = new Host(String(target), { withCredentials: settings.withCredentials ?? false });
+		} catch (cause) {
+			status.value = "closed";
+			fail({
+				kind: "connect",
+				cause
+			});
+			scheduleReconnect();
+			return;
+		}
+		source.value = instance;
+		status.value = "connecting";
+		const onOpen = () => {
+			status.value = "open";
+			error.value = void 0;
+			attempts = 0;
+		};
+		const onError = (nativeEvent) => {
+			fail({
+				kind: "error",
+				event: nativeEvent
+			});
+			if (instance.readyState === CLOSED) {
+				dispose();
+				status.value = "closed";
+				scheduleReconnect();
+			} else status.value = "connecting";
+		};
+		const listeners = /* @__PURE__ */ new Map();
+		const names = settings.events ?? ["message"];
+		for (const name of names) {
+			const listener = (nativeEvent) => {
+				const raw = "data" in nativeEvent ? nativeEvent.data : "";
+				const id = "lastEventId" in nativeEvent ? nativeEvent.lastEventId : "";
+				deliver(name, typeof raw === "string" ? raw : String(raw), typeof id === "string" ? id : "");
+			};
+			listeners.set(name, listener);
+			instance.addEventListener(name, listener);
+		}
+		instance.addEventListener("open", onOpen);
+		instance.addEventListener("error", onError);
+		detach = () => {
+			instance.removeEventListener("open", onOpen);
+			instance.removeEventListener("error", onError);
+			for (const [name, listener] of listeners) instance.removeEventListener(name, listener);
+		};
+	};
+	const open = () => {
+		manuallyClosed = false;
+		attempts = 0;
+		connect();
+	};
+	const close = () => {
+		manuallyClosed = true;
+		if (reconnectTimer !== void 0) {
+			scheduler.clearTimeout(reconnectTimer);
+			reconnectTimer = void 0;
+		}
+		dispose();
+		status.value = "closed";
+	};
+	const on = (name, handler) => {
+		const wrapped = (value, id) => {
+			handler(eventData(value), id);
+		};
+		const set = handlers.get(name) ?? /* @__PURE__ */ new Set();
+		set.add(wrapped);
+		handlers.set(name, set);
+		return () => {
+			set.delete(wrapped);
+		};
+	};
+	if (settings.host !== void 0 || typeof window !== "undefined") {
+		let initial = true;
+		tryOnScopeDispose(watch([() => toValue(url), resolveHost], ([target]) => {
+			const first = initial;
+			initial = false;
+			if (first && !(settings.immediate ?? true)) return;
+			if (!first && source.value === void 0 && reconnectTimer === void 0) return;
+			if (target === null || target === void 0) close();
+			else open();
+		}, { immediate: true }));
+	}
+	tryOnScopeDispose(close);
+	return {
+		status: readonly(status),
+		message,
+		data,
+		event,
+		lastEventId,
+		error,
+		source,
+		on,
+		open,
+		close
+	};
+}
+//#endregion
+export { useEventSource };

package/dist/use-eye-dropper.d.mts

@@ -0,0 +1,79 @@
+import { ComputedRef, MaybeRef, Ref } from "vue";
+
+//#region src/use-eye-dropper.d.ts
+/** Color picked by the EyeDropper API. */
+interface EyeDropperColor {
+  /** Picked color as a `#rrggbb` string. */
+  readonly sRGBHex: string;
+}
+/** Minimal `EyeDropper` instance. */
+interface EyeDropperLike {
+  /** Open the picker. Rejects with AbortError when dismissed or aborted. */
+  open(options?: {
+    signal?: AbortSignal;
+  }): Promise<EyeDropperColor>;
+}
+/** Minimal `EyeDropper` constructor. */
+type EyeDropperHost = new () => EyeDropperLike;
+/** Options for {@link useEyeDropper}. */
+interface UseEyeDropperOptions {
+  /**
+   * EyeDropper constructor for alternate runtimes and tests. A ref (not a
+   * getter) because the host itself is a constructor function.
+   *
+   * @default window.EyeDropper when it exists
+   */
+  readonly host?: MaybeRef<EyeDropperHost | null | undefined>;
+  /**
+   * Initial `sRGBHex` value.
+   *
+   * @default ""
+   */
+  readonly initialValue?: string;
+}
+/** Discriminated outcome of {@link EyeDropperControls.open}. */
+type EyeDropperResult = {
+  /** A color was picked. */readonly status: "picked"; /** Picked color. */
+  readonly sRGBHex: string;
+} | {
+  /** Dismissed/aborted, missing API, or another failure. */readonly status: "cancelled" | "unsupported" | "failed"; /** Exact error thrown by the host, when one was thrown. */
+  readonly error: unknown;
+};
+/** Reactive state and actions returned by {@link useEyeDropper}. */
+interface EyeDropperControls {
+  /** Whether the EyeDropper API is available. */
+  readonly supported: ComputedRef<boolean>;
+  /** Most recently picked color. */
+  readonly sRGBHex: Readonly<Ref<string>>;
+  /** Whether the picker is open. */
+  readonly picking: Readonly<Ref<boolean>>;
+  /**
+   * Open the picker. Browsers require a user gesture.
+   *
+   * @param signal Aborts the open picker.
+   * @returns The discriminated outcome; never rejects.
+   */
+  readonly open: (signal?: AbortSignal) => Promise<EyeDropperResult>;
+}
+/**
+ * Pick a color from anywhere on screen with the EyeDropper API.
+ *
+ * `open` resolves to a discriminated {@link EyeDropperResult}; dismissing
+ * the picker (Escape) or aborting via `signal` yields `"cancelled"`.
+ * The composable holds no resources beyond an open picker, which the
+ * caller controls through `signal`.
+ *
+ * Server rendering: `supported` is false and `sRGBHex` is `initialValue`.
+ *
+ * @example
+ * ```ts
+ * const { open, sRGBHex, supported } = useEyeDropper();
+ * ```
+ *
+ * @param options Capability and initial color.
+ * @default options {}
+ * @returns Picker state and the open action.
+ */
+declare function useEyeDropper(options?: UseEyeDropperOptions): EyeDropperControls;
+//#endregion
+export { EyeDropperColor, EyeDropperControls, EyeDropperHost, EyeDropperLike, EyeDropperResult, UseEyeDropperOptions, useEyeDropper };