@depup/lottie-react 2.4.1-depup.0 → 3.0.0-depup.0

package/build/interactions/lottieScrollScrub.cjs

@@ -0,0 +1,152 @@
+const require_types = require("../animation/types.cjs");
+const require_coverProgress = require("./coverProgress.cjs");
+//#region src/interactions/lottieScrollScrub.ts
+function isRange(value) {
+	return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function isScrubOptions(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if ("range" in value && !isRange(value.range)) return false;
+	if ("axis" in value && value.axis !== "block" && value.axis !== "inline") return false;
+	if ("onRangeEnter" in value && typeof value.onRangeEnter !== "function") return false;
+	return !("onRangeLeave" in value && typeof value.onRangeLeave !== "function");
+}
+function attachScrollScrub(context, raw) {
+	const options = isScrubOptions(raw) ? raw : {};
+	const range = options.range ?? [0, 1];
+	const axis = options.axis ?? "block";
+	let observer = null;
+	let observedRoot = null;
+	let timeline = null;
+	let frameHandle = null;
+	let scrubbing = false;
+	let gestureStarted = false;
+	let previousBand = null;
+	let warnedInactive = false;
+	const readProgress = (root) => {
+		if (timeline !== null) {
+			const time = timeline.currentTime;
+			if (typeof time === "number") return Math.min(Math.max(time / 100, 0), 1);
+			if (time !== null && typeof time === "object" && "value" in time && typeof time.value === "number") return Math.min(Math.max(time.value / 100, 0), 1);
+			if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+				if (!warnedInactive) {
+					warnedInactive = true;
+					console.warn("[lottie-react] the scroll timeline reported no position, so the scrub fell back to measuring the element itself. This happens when nothing around the animation scrolls.");
+				}
+			}
+		}
+		return require_coverProgress.coverProgress(root.getBoundingClientRect(), {
+			width: window.innerWidth,
+			height: window.innerHeight
+		}, axis);
+	};
+	const sample = () => {
+		frameHandle = null;
+		const root = context.lottie.root;
+		if (!scrubbing || root === null) return;
+		if (context.lottie.state === require_types.LottieState.loading) {
+			frameHandle = requestAnimationFrame(sample);
+			return;
+		}
+		const band = require_coverProgress.bandProgress(readProgress(root), range);
+		const events = require_coverProgress.bandEdges(previousBand, band);
+		previousBand = band;
+		context.lottie.scrubTo(band * context.lottie.playableFrames);
+		if (events.enter !== void 0 || events.leave !== void 0) {
+			const liveRaw = context.options();
+			const live = isScrubOptions(liveRaw) ? liveRaw : {};
+			if (events.enter !== void 0) live.onRangeEnter?.(events.enter, context.lottie);
+			if (events.leave !== void 0) live.onRangeLeave?.(events.leave, context.lottie);
+		}
+		frameHandle = requestAnimationFrame(sample);
+	};
+	const startScrubbing = () => {
+		if (scrubbing) return;
+		scrubbing = true;
+		previousBand = null;
+		if (context.lottie.state !== require_types.LottieState.loading) {
+			gestureStarted = true;
+			context.lottie.scrubStart();
+		}
+		sample();
+	};
+	const stopScrubbing = () => {
+		if (!scrubbing) return;
+		scrubbing = false;
+		gestureStarted = false;
+		if (frameHandle !== null) {
+			cancelAnimationFrame(frameHandle);
+			frameHandle = null;
+		}
+		context.lottie.scrubEnd();
+	};
+	const handleEntries = (entries) => {
+		const entry = entries.at(-1);
+		if (entry === void 0) return;
+		if (entry.isIntersecting) startScrubbing();
+		else stopScrubbing();
+	};
+	const arm = () => {
+		const root = context.lottie.root;
+		if (root === observedRoot) return;
+		stopScrubbing();
+		observer?.disconnect();
+		observer = null;
+		timeline = null;
+		observedRoot = root;
+		if (root === null) return;
+		const ViewTimelineCtor = globalThis.ViewTimeline;
+		if (ViewTimelineCtor !== void 0) timeline = new ViewTimelineCtor({
+			subject: root,
+			axis
+		});
+		observer = new IntersectionObserver(handleEntries);
+		observer.observe(root);
+	};
+	const stopListening = context.onChange(() => {
+		if (scrubbing && !gestureStarted && context.lottie.state !== require_types.LottieState.loading && context.lottie.state !== require_types.LottieState.error) {
+			gestureStarted = true;
+			context.lottie.scrubStart();
+		}
+		arm();
+	});
+	arm();
+	return () => {
+		stopListening();
+		stopScrubbing();
+		observer?.disconnect();
+	};
+}
+/**
+* Ties the playhead to how far the animation has travelled through the
+* viewport, so scrolling scrubs it instead of time playing it.
+*
+* ```jsx
+* <LottieInteractions
+*   interactions={[
+*     lottieScrollScrub({
+*       range: [0.2, 0.45],
+*       onRangeLeave: (direction, lottie) => {
+*         if (direction === "forward") lottie.playSegments([[45, 60]]);
+*       },
+*     }),
+*   ]}
+* >
+*   <Lottie src={story} autoplay={false} />
+* </LottieInteractions>
+* ```
+*
+* Progress is the platform's own scroll timeline where the browser has one,
+* and the same arithmetic measured by hand where it does not; the numbers
+* agree by construction. While the animation is out of view nothing samples
+* at all, and playback state is held by the scrub gesture, so whatever was
+* true before the scrub is restored when it leaves.
+*/
+function lottieScrollScrub(options = {}) {
+	return {
+		attach: attachScrollScrub,
+		options
+	};
+}
+//#endregion
+exports.lottieScrollScrub = lottieScrollScrub;

package/build/interactions/lottieScrollScrub.d.cts

@@ -0,0 +1,47 @@
+import { LottieInstance } from "../animation/types.cjs";
+import { LottieInteraction } from "./types.cjs";
+//#region src/interactions/lottieScrollScrub.d.ts
+/** What {@link lottieScrollScrub} can be told. */
+interface LottieScrollScrubOptions {
+  /**
+   * The stretch of the element's journey the animation maps onto, as
+   * fractions 0 to 1 of it. Below the range the animation holds its first
+   * frame and above it its last, which is what clamping does. The whole
+   * journey unless narrowed.
+   */
+  range?: readonly [number, number];
+  /** Which axis the journey runs along. The block axis unless said otherwise. */
+  axis?: "block" | "inline";
+  /** Called as the playhead's band is entered, with the travel direction. */
+  onRangeEnter?: (direction: "forward" | "backward", lottie: LottieInstance) => void;
+  /** Called as the band is left: at its far edge forward, its near edge back. */
+  onRangeLeave?: (direction: "forward" | "backward", lottie: LottieInstance) => void;
+}
+/**
+ * Ties the playhead to how far the animation has travelled through the
+ * viewport, so scrolling scrubs it instead of time playing it.
+ *
+ * ```jsx
+ * <LottieInteractions
+ *   interactions={[
+ *     lottieScrollScrub({
+ *       range: [0.2, 0.45],
+ *       onRangeLeave: (direction, lottie) => {
+ *         if (direction === "forward") lottie.playSegments([[45, 60]]);
+ *       },
+ *     }),
+ *   ]}
+ * >
+ *   <Lottie src={story} autoplay={false} />
+ * </LottieInteractions>
+ * ```
+ *
+ * Progress is the platform's own scroll timeline where the browser has one,
+ * and the same arithmetic measured by hand where it does not; the numbers
+ * agree by construction. While the animation is out of view nothing samples
+ * at all, and playback state is held by the scrub gesture, so whatever was
+ * true before the scrub is restored when it leaves.
+ */
+declare function lottieScrollScrub(options?: LottieScrollScrubOptions): LottieInteraction;
+//#endregion
+export { LottieScrollScrubOptions, lottieScrollScrub };

package/build/interactions/lottieScrollScrub.d.ts

@@ -0,0 +1,47 @@
+import { LottieInstance } from "../animation/types.js";
+import { LottieInteraction } from "./types.js";
+//#region src/interactions/lottieScrollScrub.d.ts
+/** What {@link lottieScrollScrub} can be told. */
+interface LottieScrollScrubOptions {
+  /**
+   * The stretch of the element's journey the animation maps onto, as
+   * fractions 0 to 1 of it. Below the range the animation holds its first
+   * frame and above it its last, which is what clamping does. The whole
+   * journey unless narrowed.
+   */
+  range?: readonly [number, number];
+  /** Which axis the journey runs along. The block axis unless said otherwise. */
+  axis?: "block" | "inline";
+  /** Called as the playhead's band is entered, with the travel direction. */
+  onRangeEnter?: (direction: "forward" | "backward", lottie: LottieInstance) => void;
+  /** Called as the band is left: at its far edge forward, its near edge back. */
+  onRangeLeave?: (direction: "forward" | "backward", lottie: LottieInstance) => void;
+}
+/**
+ * Ties the playhead to how far the animation has travelled through the
+ * viewport, so scrolling scrubs it instead of time playing it.
+ *
+ * ```jsx
+ * <LottieInteractions
+ *   interactions={[
+ *     lottieScrollScrub({
+ *       range: [0.2, 0.45],
+ *       onRangeLeave: (direction, lottie) => {
+ *         if (direction === "forward") lottie.playSegments([[45, 60]]);
+ *       },
+ *     }),
+ *   ]}
+ * >
+ *   <Lottie src={story} autoplay={false} />
+ * </LottieInteractions>
+ * ```
+ *
+ * Progress is the platform's own scroll timeline where the browser has one,
+ * and the same arithmetic measured by hand where it does not; the numbers
+ * agree by construction. While the animation is out of view nothing samples
+ * at all, and playback state is held by the scrub gesture, so whatever was
+ * true before the scrub is restored when it leaves.
+ */
+declare function lottieScrollScrub(options?: LottieScrollScrubOptions): LottieInteraction;
+//#endregion
+export { LottieScrollScrubOptions, lottieScrollScrub };

package/build/interactions/lottieScrollScrub.js

@@ -0,0 +1,152 @@
+import { LottieState } from "../animation/types.js";
+import { bandEdges, bandProgress, coverProgress } from "./coverProgress.js";
+//#region src/interactions/lottieScrollScrub.ts
+function isRange(value) {
+	return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function isScrubOptions(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if ("range" in value && !isRange(value.range)) return false;
+	if ("axis" in value && value.axis !== "block" && value.axis !== "inline") return false;
+	if ("onRangeEnter" in value && typeof value.onRangeEnter !== "function") return false;
+	return !("onRangeLeave" in value && typeof value.onRangeLeave !== "function");
+}
+function attachScrollScrub(context, raw) {
+	const options = isScrubOptions(raw) ? raw : {};
+	const range = options.range ?? [0, 1];
+	const axis = options.axis ?? "block";
+	let observer = null;
+	let observedRoot = null;
+	let timeline = null;
+	let frameHandle = null;
+	let scrubbing = false;
+	let gestureStarted = false;
+	let previousBand = null;
+	let warnedInactive = false;
+	const readProgress = (root) => {
+		if (timeline !== null) {
+			const time = timeline.currentTime;
+			if (typeof time === "number") return Math.min(Math.max(time / 100, 0), 1);
+			if (time !== null && typeof time === "object" && "value" in time && typeof time.value === "number") return Math.min(Math.max(time.value / 100, 0), 1);
+			if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+				if (!warnedInactive) {
+					warnedInactive = true;
+					console.warn("[lottie-react] the scroll timeline reported no position, so the scrub fell back to measuring the element itself. This happens when nothing around the animation scrolls.");
+				}
+			}
+		}
+		return coverProgress(root.getBoundingClientRect(), {
+			width: window.innerWidth,
+			height: window.innerHeight
+		}, axis);
+	};
+	const sample = () => {
+		frameHandle = null;
+		const root = context.lottie.root;
+		if (!scrubbing || root === null) return;
+		if (context.lottie.state === LottieState.loading) {
+			frameHandle = requestAnimationFrame(sample);
+			return;
+		}
+		const band = bandProgress(readProgress(root), range);
+		const events = bandEdges(previousBand, band);
+		previousBand = band;
+		context.lottie.scrubTo(band * context.lottie.playableFrames);
+		if (events.enter !== void 0 || events.leave !== void 0) {
+			const liveRaw = context.options();
+			const live = isScrubOptions(liveRaw) ? liveRaw : {};
+			if (events.enter !== void 0) live.onRangeEnter?.(events.enter, context.lottie);
+			if (events.leave !== void 0) live.onRangeLeave?.(events.leave, context.lottie);
+		}
+		frameHandle = requestAnimationFrame(sample);
+	};
+	const startScrubbing = () => {
+		if (scrubbing) return;
+		scrubbing = true;
+		previousBand = null;
+		if (context.lottie.state !== LottieState.loading) {
+			gestureStarted = true;
+			context.lottie.scrubStart();
+		}
+		sample();
+	};
+	const stopScrubbing = () => {
+		if (!scrubbing) return;
+		scrubbing = false;
+		gestureStarted = false;
+		if (frameHandle !== null) {
+			cancelAnimationFrame(frameHandle);
+			frameHandle = null;
+		}
+		context.lottie.scrubEnd();
+	};
+	const handleEntries = (entries) => {
+		const entry = entries.at(-1);
+		if (entry === void 0) return;
+		if (entry.isIntersecting) startScrubbing();
+		else stopScrubbing();
+	};
+	const arm = () => {
+		const root = context.lottie.root;
+		if (root === observedRoot) return;
+		stopScrubbing();
+		observer?.disconnect();
+		observer = null;
+		timeline = null;
+		observedRoot = root;
+		if (root === null) return;
+		const ViewTimelineCtor = globalThis.ViewTimeline;
+		if (ViewTimelineCtor !== void 0) timeline = new ViewTimelineCtor({
+			subject: root,
+			axis
+		});
+		observer = new IntersectionObserver(handleEntries);
+		observer.observe(root);
+	};
+	const stopListening = context.onChange(() => {
+		if (scrubbing && !gestureStarted && context.lottie.state !== LottieState.loading && context.lottie.state !== LottieState.error) {
+			gestureStarted = true;
+			context.lottie.scrubStart();
+		}
+		arm();
+	});
+	arm();
+	return () => {
+		stopListening();
+		stopScrubbing();
+		observer?.disconnect();
+	};
+}
+/**
+* Ties the playhead to how far the animation has travelled through the
+* viewport, so scrolling scrubs it instead of time playing it.
+*
+* ```jsx
+* <LottieInteractions
+*   interactions={[
+*     lottieScrollScrub({
+*       range: [0.2, 0.45],
+*       onRangeLeave: (direction, lottie) => {
+*         if (direction === "forward") lottie.playSegments([[45, 60]]);
+*       },
+*     }),
+*   ]}
+* >
+*   <Lottie src={story} autoplay={false} />
+* </LottieInteractions>
+* ```
+*
+* Progress is the platform's own scroll timeline where the browser has one,
+* and the same arithmetic measured by hand where it does not; the numbers
+* agree by construction. While the animation is out of view nothing samples
+* at all, and playback state is held by the scrub gesture, so whatever was
+* true before the scrub is restored when it leaves.
+*/
+function lottieScrollScrub(options = {}) {
+	return {
+		attach: attachScrollScrub,
+		options
+	};
+}
+//#endregion
+export { lottieScrollScrub };

package/build/interactions/types.d.cts

@@ -0,0 +1,46 @@
+import { LottieInstance } from "../animation/types.cjs";
+//#region src/interactions/types.d.ts
+/**
+ * What a behaviour is handed when it attaches to one animation.
+ *
+ * Everything here reads live. `lottie` is the animation as it is right now,
+ * never a captured copy, because the instance object is rebuilt every render
+ * and anything held across renders would be the past. `options` is the same
+ * for the descriptor's options, which is how a callback option is read fresh
+ * at the moment an event fires without the behaviour ever re-attaching.
+ */
+interface LottieInteractionContext {
+  /** The animation: values, commands, `subscribe`, `root`. Read fresh each use. */
+  readonly lottie: LottieInstance;
+  /** The descriptor's options as they are right now. */
+  options: () => unknown;
+  /**
+   * Fires when something about the animation changed: its root arrived, its
+   * values moved, or its options were edited. A behaviour re-checks what it
+   * armed against and returns early when nothing it uses has changed.
+   */
+  onChange: (listener: () => void) => () => void;
+  /**
+   * Scratch that survives an option change, for state that must outlive the
+   * re-attach an option change causes: a once-latch is the worked example.
+   * Cleared when the interaction leaves the list or everything unmounts.
+   */
+  memory: Record<string, unknown>;
+}
+/**
+ * One behaviour in an `interactions` list: a stable implementation plus the
+ * plain data it was configured with. Factories such as `lottieInView` make
+ * these; nothing else needs to.
+ *
+ * The split is load-bearing. Implementations compare by identity and options
+ * by content, so a list written inline at the call site re-arms nothing, and
+ * an option that really changed re-arms only its own behaviour. `attach`
+ * narrows `options` itself with its own guard and returns the cleanup that
+ * detaches, or nothing when there was nothing to attach.
+ */
+interface LottieInteraction {
+  attach: (context: LottieInteractionContext, options: unknown) => (() => void) | undefined;
+  options: unknown;
+}
+//#endregion
+export { LottieInteraction, LottieInteractionContext };

package/build/interactions/types.d.ts

@@ -0,0 +1,46 @@
+import { LottieInstance } from "../animation/types.js";
+//#region src/interactions/types.d.ts
+/**
+ * What a behaviour is handed when it attaches to one animation.
+ *
+ * Everything here reads live. `lottie` is the animation as it is right now,
+ * never a captured copy, because the instance object is rebuilt every render
+ * and anything held across renders would be the past. `options` is the same
+ * for the descriptor's options, which is how a callback option is read fresh
+ * at the moment an event fires without the behaviour ever re-attaching.
+ */
+interface LottieInteractionContext {
+  /** The animation: values, commands, `subscribe`, `root`. Read fresh each use. */
+  readonly lottie: LottieInstance;
+  /** The descriptor's options as they are right now. */
+  options: () => unknown;
+  /**
+   * Fires when something about the animation changed: its root arrived, its
+   * values moved, or its options were edited. A behaviour re-checks what it
+   * armed against and returns early when nothing it uses has changed.
+   */
+  onChange: (listener: () => void) => () => void;
+  /**
+   * Scratch that survives an option change, for state that must outlive the
+   * re-attach an option change causes: a once-latch is the worked example.
+   * Cleared when the interaction leaves the list or everything unmounts.
+   */
+  memory: Record<string, unknown>;
+}
+/**
+ * One behaviour in an `interactions` list: a stable implementation plus the
+ * plain data it was configured with. Factories such as `lottieInView` make
+ * these; nothing else needs to.
+ *
+ * The split is load-bearing. Implementations compare by identity and options
+ * by content, so a list written inline at the call site re-arms nothing, and
+ * an option that really changed re-arms only its own behaviour. `attach`
+ * narrows `options` itself with its own guard and returns the cleanup that
+ * detaches, or nothing when there was nothing to attach.
+ */
+interface LottieInteraction {
+  attach: (context: LottieInteractionContext, options: unknown) => (() => void) | undefined;
+  options: unknown;
+}
+//#endregion
+export { LottieInteraction, LottieInteractionContext };

package/build/interactions/useInteractionsRunner.cjs

@@ -0,0 +1,142 @@
+const require_isSameJson = require("../utils/isSameJson.cjs");
+const require_useStableValue = require("../utils/useStableValue.cjs");
+const require_LottieRegistryContext = require("../animation/LottieRegistryContext.cjs");
+let react = require("react");
+//#region src/interactions/useInteractionsRunner.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The options with every function replaced by a marker, so the whole slot can
+* be compared by content. A callback's identity changes on every render at an
+* inline call site, which must not read as a configuration change; a callback
+* appearing or disappearing must.
+*/
+function projectData(value) {
+	if (typeof value === "function") return "[function]";
+	if (Array.isArray(value)) return value.map(projectData);
+	if (isRecord(value)) {
+		const projected = {};
+		for (const [key, entry] of Object.entries(value)) projected[key] = projectData(entry);
+		return projected;
+	}
+	return value;
+}
+/**
+* Arms every interaction on every animation a source holds, and keeps that
+* true as animations come and go, options change, and values move.
+*
+* The granularity is deliberate: an animation arriving arms only itself, a
+* changed option re-arms only its own slot on each animation, and a moved
+* value re-arms nothing and only signals `onChange`. A re-arm caused by an
+* option change hands the new attachment the old one's `memory` when the
+* implementation is the same one, which is what lets a once-latch survive
+* reconfiguration.
+*/
+function useInteractionsRunner(source, interactions) {
+	const latest = (0, react.useRef)(interactions);
+	latest.current = interactions;
+	const projected = require_useStableValue.useStableValue(interactions.map((interaction) => ({
+		attach: interaction.attach,
+		options: projectData(interaction.options)
+	})));
+	const runtime = (0, react.useRef)(/* @__PURE__ */ new Map()).current;
+	const armSlot = (box, slot, memory) => {
+		const interaction = latest.current[slot];
+		const record = {
+			key: projected[slot],
+			attachIdentity: interaction.attach,
+			cleanup: void 0,
+			listeners: /* @__PURE__ */ new Set(),
+			memory: memory ?? {}
+		};
+		const context = {
+			get lottie() {
+				return box.current;
+			},
+			options: () => latest.current[slot]?.options,
+			onChange: (listener) => {
+				record.listeners.add(listener);
+				return () => {
+					record.listeners.delete(listener);
+				};
+			},
+			memory: record.memory
+		};
+		record.cleanup = interaction.attach(context, interaction.options);
+		return record;
+	};
+	const armRef = (0, react.useRef)(armSlot);
+	armRef.current = armSlot;
+	(0, react.useEffect)(() => {
+		const attachBox = (box) => {
+			runtime.set(box, projected.map((_, slot) => armRef.current(box, slot)));
+		};
+		const syncSlots = () => {
+			for (const [box, attachments] of runtime) {
+				for (let slot = 0; slot < projected.length; slot += 1) {
+					const existing = attachments[slot];
+					if (existing !== void 0 && require_isSameJson.isSameJson(existing.key, projected[slot])) continue;
+					const inherited = existing !== void 0 && existing.attachIdentity === latest.current[slot]?.attach ? existing.memory : void 0;
+					existing?.cleanup?.();
+					attachments[slot] = armRef.current(box, slot, inherited);
+				}
+				for (const removed of attachments.splice(projected.length)) removed.cleanup?.();
+			}
+		};
+		const syncBoxes = () => {
+			const current = new Set(source.boxes());
+			for (const box of current) if (!runtime.has(box)) attachBox(box);
+			for (const [box, attachments] of [...runtime]) if (!current.has(box)) {
+				for (const attachment of attachments) attachment.cleanup?.();
+				runtime.delete(box);
+			}
+		};
+		const notifyChange = () => {
+			for (const attachments of runtime.values()) for (const attachment of attachments) for (const listener of [...attachment.listeners]) listener();
+		};
+		syncSlots();
+		syncBoxes();
+		return source.subscribe(() => {
+			syncBoxes();
+			notifyChange();
+		});
+	}, [
+		source,
+		projected,
+		runtime
+	]);
+	(0, react.useEffect)(() => {
+		return () => {
+			for (const attachments of runtime.values()) for (const attachment of attachments) attachment.cleanup?.();
+			runtime.clear();
+		};
+	}, [runtime]);
+}
+/**
+* A source holding exactly one animation, for the positions where the
+* component or the hook was handed an instance rather than wrapping a subtree.
+* Mirrors the registration the animation itself performs toward a surrounding
+* wrapper, so the runner cannot tell the two apart.
+*/
+function useSingleInstanceSource(instance) {
+	const [store] = (0, react.useState)(require_LottieRegistryContext.createLottieRegistry);
+	const box = (0, react.useRef)(null);
+	if (instance !== null) {
+		if (box.current === null) box.current = { current: instance };
+		else box.current.current = instance;
+	}
+	const present = instance !== null;
+	(0, react.useEffect)(() => {
+		const current = box.current;
+		if (!present || current === null) return;
+		return store.register(current);
+	}, [store, present]);
+	(0, react.useEffect)(() => {
+		if (present) store.bump();
+	});
+	return store;
+}
+//#endregion
+exports.useInteractionsRunner = useInteractionsRunner;
+exports.useSingleInstanceSource = useSingleInstanceSource;