@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/manager/_manager-chunks/runtime-BhkT2CXl.js

@@ -0,0 +1,1408 @@
+import { n as __esmMin } from "./runtime-EITvVbkG.js";
+import { Cr as useSyncExternalStore, Ft as useParameter, G as Separator, Lt as useStorybookApi, Nt as useGlobalTypes, Pt as useGlobals, Sr as useState, Tt as init_manager_api, W as Select, fr as useCallback, hr as useEffect, lr as init__storybook_global_react, nr as _storybook_global_react_default, ot as init_components, xr as useRef, yr as useMemo } from "./runtime-Bly6WJLN.js";
+import { c as Icons, l as init_icon } from "./runtime-B1L9TH89.js";
+import { i as init_esm, r as dedent } from "./runtime-i-PDAHLR.js";
+import { d as isEqual, u as init_isEqual } from "./runtime-D94Vq3oR.js";
+import { a as StatusTypeIdMismatchError$1, o as UniversalStoreFollowerTimeoutError, s as init_manager_errors } from "./runtime-cp5pazY2.js";
+import { n as init_preview_errors, t as StatusTypeIdMismatchError$2 } from "./runtime-BK0zF7FN.js";
+//#region src/toolbar/utils/normalize-toolbar-arg-type.ts
+var normalizeArgType;
+function init_normalize_toolbar_arg_type() {
+	return (init_normalize_toolbar_arg_type = __esmMin((() => {
+		normalizeArgType = (key, argType) => {
+			const toolbar = argType.toolbar;
+			if (!toolbar) return null;
+			return {
+				...argType,
+				toolbar: {
+					...argType.toolbar,
+					items: toolbar.items.map((_item) => {
+						const item = typeof _item === "string" ? {
+							value: _item,
+							title: _item
+						} : _item;
+						if (item.type === "reset" && toolbar.icon) {
+							item.icon = toolbar.icon;
+							item.hideIcon = true;
+							item.value = void 0;
+						}
+						return item;
+					})
+				}
+			};
+		};
+	})))();
+}
+//#endregion
+//#region src/toolbar/utils/get-selected.ts
+var getSelectedItem;
+function init_get_selected() {
+	return (init_get_selected = __esmMin((() => {
+		getSelectedItem = ({ currentValue, items }) => {
+			return items.find((item) => item.value === currentValue && item.type !== "reset");
+		};
+	})))();
+}
+//#endregion
+//#region src/toolbar/constants.ts
+var TOOLBAR_ID;
+function init_constants() {
+	return (init_constants = __esmMin((() => {
+		TOOLBAR_ID = "toolbar";
+	})))();
+}
+//#endregion
+//#region src/toolbar/utils/register-shortcuts.ts
+var registerShortcuts;
+function init_register_shortcuts() {
+	return (init_register_shortcuts = __esmMin((() => {
+		init_constants();
+		registerShortcuts = async (api, id, shortcuts) => {
+			if (shortcuts.next) await api.setAddonShortcut(TOOLBAR_ID, {
+				label: shortcuts.next.label,
+				defaultShortcut: shortcuts.next.keys,
+				actionName: `${id}:next`,
+				action: shortcuts.next.action
+			});
+			if (shortcuts.previous) await api.setAddonShortcut(TOOLBAR_ID, {
+				label: shortcuts.previous.label,
+				defaultShortcut: shortcuts.previous.keys,
+				actionName: `${id}:previous`,
+				action: shortcuts.previous.action
+			});
+			if (shortcuts.reset) await api.setAddonShortcut(TOOLBAR_ID, {
+				label: shortcuts.reset.label,
+				defaultShortcut: shortcuts.reset.keys,
+				actionName: `${id}:reset`,
+				action: shortcuts.reset.action
+			});
+		};
+	})))();
+}
+//#endregion
+//#region src/toolbar/components/ToolbarMenuSelect.module.css
+var id, ToolbarMenuSelect_module_default;
+function init_ToolbarMenuSelect_module() {
+	return (init_ToolbarMenuSelect_module = __esmMin((() => {
+		id = "core/src/toolbar/components/ToolbarMenuSelect.module.css";
+		if (typeof document !== "undefined" && !document.querySelector(`style[data-sb-css="${id}"]`)) {
+			const style = document.createElement("style");
+			style.setAttribute("data-sb-css", id);
+			style.textContent = ".sb-FCSgfW-item{align-items:center;gap:8px;width:100%;display:flex}.sb-FCSgfW-itemMiddle{flex:1}";
+			document.head.appendChild(style);
+		}
+		ToolbarMenuSelect_module_default = {
+			"item": "sb-FCSgfW-item",
+			"itemMiddle": "sb-FCSgfW-itemMiddle"
+		};
+	})))();
+}
+//#endregion
+//#region src/toolbar/components/ToolbarMenuSelect.tsx
+var ToolbarMenuSelect;
+function init_ToolbarMenuSelect() {
+	return (init_ToolbarMenuSelect = __esmMin((() => {
+		init__storybook_global_react();
+		init_components();
+		init_manager_api();
+		init_icon();
+		init_get_selected();
+		init_register_shortcuts();
+		init_ToolbarMenuSelect_module();
+		ToolbarMenuSelect = ({ id, name, description, toolbar: { icon: _icon, items, title: _title, preventDynamicIcon, dynamicTitle = true, shortcuts } }) => {
+			const api = useStorybookApi();
+			const [globals, updateGlobals, storyGlobals] = useGlobals();
+			const currentValue = globals[id];
+			const isOverridden = id in storyGlobals;
+			let icon = _icon;
+			let title = _title;
+			if (!preventDynamicIcon) icon = getSelectedItem({
+				currentValue,
+				items
+			})?.icon || icon;
+			if (dynamicTitle) title = getSelectedItem({
+				currentValue,
+				items
+			})?.title || title;
+			if (!title && !icon) console.warn(`Toolbar '${id}' has no title or icon`);
+			const resetItem = items.find((item) => item.type === "reset");
+			const resetLabel = resetItem?.title;
+			const options = _storybook_global_react_default.useMemo(() => items.filter((item) => item.type !== "reset").map((item) => {
+				const itemTitle = item.title ?? item.value ?? "Untitled";
+				const iconComponent = !item.hideIcon && item.icon ? /* @__PURE__ */ _storybook_global_react_default.createElement(Icons, {
+					icon: item.icon,
+					__suppressDeprecationWarning: true
+				}) : void 0;
+				if (item.right) return {
+					title: itemTitle,
+					value: item.value,
+					children: /* @__PURE__ */ _storybook_global_react_default.createElement("div", { className: ToolbarMenuSelect_module_default.item }, iconComponent, /* @__PURE__ */ _storybook_global_react_default.createElement("div", { className: ToolbarMenuSelect_module_default.itemMiddle }, item.title ?? item.value), item.right)
+				};
+				else return {
+					title: itemTitle,
+					value: item.value,
+					icon: iconComponent
+				};
+			}), [items]);
+			_storybook_global_react_default.useEffect(() => {
+				if (shortcuts) {
+					const length = options.length;
+					registerShortcuts(api, id, {
+						next: {
+							...shortcuts.next,
+							action: () => {
+								const idx = options.findIndex((i) => i.value === globals[id]);
+								const nextIdx = idx < 0 ? 0 : (idx + 1) % length;
+								updateGlobals({ [id]: options[nextIdx].value });
+							}
+						},
+						previous: {
+							...shortcuts.previous,
+							action: () => {
+								const idx = options.findIndex((i) => i.value === globals[id]);
+								const previousIdx = idx < 0 ? length - 1 : (idx + length - 1) % length;
+								updateGlobals({ [id]: options[previousIdx].value });
+							}
+						},
+						reset: {
+							...shortcuts.reset,
+							action: () => {
+								updateGlobals({ [id]: void 0 });
+							}
+						}
+					});
+				}
+			}, [
+				api,
+				id,
+				shortcuts,
+				globals,
+				options,
+				updateGlobals
+			]);
+			const ariaLabel = description || title || name || id;
+			return /* @__PURE__ */ _storybook_global_react_default.createElement(Select, {
+				defaultOptions: [currentValue],
+				options,
+				disabled: isOverridden,
+				ariaLabel,
+				tooltip: ariaLabel,
+				resetLabel,
+				onReset: resetItem ? () => updateGlobals({ [id]: resetItem?.value }) : void 0,
+				onSelect: (selected) => updateGlobals({ [id]: selected }),
+				icon: icon && /* @__PURE__ */ _storybook_global_react_default.createElement(Icons, {
+					icon,
+					__suppressDeprecationWarning: true
+				}),
+				showSelectedOptionTitle: dynamicTitle
+			}, title);
+		};
+	})))();
+}
+//#endregion
+//#region src/toolbar/components/ToolbarManager.tsx
+var ToolbarManager;
+function init_ToolbarManager() {
+	return (init_ToolbarManager = __esmMin((() => {
+		init__storybook_global_react();
+		init_components();
+		init_manager_api();
+		init_normalize_toolbar_arg_type();
+		init_ToolbarMenuSelect();
+		ToolbarManager = () => {
+			const globalTypes = useGlobalTypes();
+			if (!Object.keys(globalTypes).some((id) => !!globalTypes[id].toolbar)) return null;
+			return /* @__PURE__ */ _storybook_global_react_default.createElement(_storybook_global_react_default.Fragment, null, /* @__PURE__ */ _storybook_global_react_default.createElement(Separator, null), Object.keys(globalTypes).map((id) => {
+				const normalizedArgType = normalizeArgType(id, globalTypes[id]);
+				return normalizedArgType && /* @__PURE__ */ _storybook_global_react_default.createElement(ToolbarMenuSelect, {
+					key: id,
+					id,
+					...normalizedArgType
+				});
+			}));
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/review/routes.ts
+var REVIEW_COLLECTION_QUERY_PARAM, isReviewSummaryPath, isReviewCollectionStoryRoute;
+function init_routes() {
+	return (init_routes = __esmMin((() => {
+		REVIEW_COLLECTION_QUERY_PARAM = "collection";
+		isReviewSummaryPath = (path) => path === "/review/" || path === "/review";
+		isReviewCollectionStoryRoute = (path, customQueryParams) => !!path && path.startsWith("/story/") && customQueryParams?.["collection"] !== void 0;
+	})))();
+}
+//#endregion
+//#region src/shared/announce.ts
+function getRegion(politeness) {
+	let region = regions.get(politeness);
+	if (!region?.isConnected) {
+		region = document.createElement("div");
+		region.setAttribute("aria-live", politeness);
+		region.setAttribute("role", "log");
+		region.setAttribute("aria-relevant", "additions");
+		region.dataset.liveAnnouncer = "true";
+		Object.assign(region.style, {
+			position: "absolute",
+			width: "1px",
+			height: "1px",
+			margin: "-1px",
+			padding: "0",
+			border: "0",
+			overflow: "hidden",
+			clip: "rect(0 0 0 0)",
+			clipPath: "inset(50%)",
+			whiteSpace: "nowrap"
+		});
+		document.body.append(region);
+		regions.set(politeness, region);
+	}
+	return region;
+}
+/** Announces a message to screen readers. */
+function announce(message, politeness = "polite") {
+	if (typeof document === "undefined") return;
+	const node = document.createElement("div");
+	node.textContent = message;
+	getRegion(politeness).append(node);
+	setTimeout(() => node.remove(), MESSAGE_TIMEOUT);
+}
+/** Removes all messages of one politeness level. */
+function clearAnnouncer(politeness) {
+	regions.get(politeness)?.replaceChildren();
+}
+var MESSAGE_TIMEOUT, regions;
+function init_announce() {
+	return (init_announce = __esmMin((() => {
+		MESSAGE_TIMEOUT = 7e3;
+		regions = /* @__PURE__ */ new Map();
+	})))();
+}
+//#endregion
+//#region src/shared/useCopyButton.ts
+function useCopyButton({ children = "Copy", childrenOnCopy = "Copied!", content, onCopy, ariaLabel = false, ariaLabelOnCopy = false, duration = 3e3 }) {
+	const [copied, setCopied] = useState(false);
+	const timerRef = useRef(null);
+	useEffect(() => () => {
+		if (timerRef.current) clearTimeout(timerRef.current);
+	}, []);
+	const handleClick = useCallback((e) => {
+		if (timerRef.current) clearTimeout(timerRef.current);
+		const announcement = typeof ariaLabelOnCopy === "string" ? ariaLabelOnCopy : "Copied to clipboard";
+		navigator.clipboard?.writeText(content).then(() => {
+			onCopy?.(e);
+			setCopied(true);
+			announce(announcement, "polite");
+			timerRef.current = setTimeout(() => {
+				setCopied(false);
+				clearAnnouncer("polite");
+				timerRef.current = null;
+			}, duration);
+		});
+	}, [
+		content,
+		onCopy,
+		ariaLabelOnCopy,
+		duration
+	]);
+	return {
+		children: copied ? childrenOnCopy : children,
+		buttonProps: useMemo(() => ({
+			onClick: handleClick,
+			ariaLabel: copied ? ariaLabelOnCopy : ariaLabel
+		}), [
+			handleClick,
+			copied,
+			ariaLabelOnCopy,
+			ariaLabel
+		])
+	};
+}
+function init_useCopyButton() {
+	return (init_useCopyButton = __esmMin((() => {
+		init__storybook_global_react();
+		init_announce();
+	})))();
+}
+//#endregion
+//#region src/shared/review/events.ts
+var REVIEW_NAMESPACE, REVIEW_EVENTS;
+function init_events() {
+	return (init_events = __esmMin((() => {
+		REVIEW_NAMESPACE = "@aussieljk/forkbook/review";
+		REVIEW_EVENTS = { PAGEVIEW: `${REVIEW_NAMESPACE}/pageview` };
+	})))();
+}
+//#endregion
+//#region src/viewport/constants.ts
+var ADDON_ID, PARAM_KEY, RESPONSIVE_VIEWPORT_VALUE;
+function init_constants$1() {
+	return (init_constants$1 = __esmMin((() => {
+		ADDON_ID = "@aussieljk/forkbook/viewport";
+		PARAM_KEY = "viewport";
+		RESPONSIVE_VIEWPORT_VALUE = "100pct-100pct";
+	})))();
+}
+//#endregion
+//#region src/shared/constants/iframe-resize.ts
+var IFRAME_RESIZE_REQUEST_CONTEXT, isPositiveFinite, parseViewport, parseIframeResizeMessage, hasFixedViewportDimensions, iframeResizeViewportsEqual, iframeResizeDimensionsEqual;
+function init_iframe_resize() {
+	return (init_iframe_resize = __esmMin((() => {
+		init_constants$1();
+		IFRAME_RESIZE_REQUEST_CONTEXT = "iframe.resize.request";
+		isPositiveFinite = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+		parseViewport = (value) => {
+			if (!value || typeof value !== "object") return;
+			const viewport = value;
+			if (typeof viewport.name !== "string" || typeof viewport.value !== "string") return;
+			const parsed = {
+				name: viewport.name,
+				value: viewport.value
+			};
+			if (viewport.width !== void 0) {
+				if (!isPositiveFinite(viewport.width)) return;
+				parsed.width = viewport.width;
+			}
+			if (viewport.height !== void 0) {
+				if (!isPositiveFinite(viewport.height)) return;
+				parsed.height = viewport.height;
+			}
+			return parsed;
+		};
+		parseIframeResizeMessage = (data) => {
+			try {
+				const parsed = typeof data === "string" ? JSON.parse(data) : data;
+				if (parsed?.context !== "iframe.resize") return null;
+				if (!isPositiveFinite(parsed.width) || !isPositiveFinite(parsed.height)) return null;
+				const viewport = parseViewport(parsed.viewport);
+				if (parsed.viewport !== void 0 && viewport === void 0) return null;
+				return {
+					width: parsed.width,
+					height: parsed.height,
+					...viewport ? { viewport } : {}
+				};
+			} catch {
+				return null;
+			}
+		};
+		hasFixedViewportDimensions = (viewport) => !!viewport && viewport.value !== "100pct-100pct" && typeof viewport.width === "number" && viewport.width > 0 && typeof viewport.height === "number" && viewport.height > 0;
+		iframeResizeViewportsEqual = (left, right) => {
+			if (left === right) return true;
+			if (!left || !right) return !left && !right;
+			return left.name === right.name && left.value === right.value && left.width === right.width && left.height === right.height;
+		};
+		iframeResizeDimensionsEqual = (left, right) => {
+			if (!left) return false;
+			if (left.width !== right.width || left.height !== right.height) return false;
+			return iframeResizeViewportsEqual(left.viewport, right.viewport);
+		};
+	})))();
+}
+//#endregion
+//#region src/viewport/defaults.ts
+var MINIMAL_VIEWPORTS;
+function init_defaults() {
+	return (init_defaults = __esmMin((() => {
+		MINIMAL_VIEWPORTS = {
+			mobile1: {
+				name: "Small mobile",
+				styles: {
+					height: "568px",
+					width: "320px"
+				},
+				type: "mobile"
+			},
+			mobile2: {
+				name: "Large mobile",
+				styles: {
+					height: "896px",
+					width: "414px"
+				},
+				type: "mobile"
+			},
+			tablet: {
+				name: "Tablet",
+				styles: {
+					height: "1112px",
+					width: "834px"
+				},
+				type: "tablet"
+			},
+			desktop: {
+				name: "Desktop",
+				styles: {
+					height: "1024px",
+					width: "1280px"
+				},
+				type: "desktop"
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/viewport/resolveViewport.ts
+var URL_VALUE_PATTERN, normalizeGlobal$1, resolveViewport;
+function init_resolveViewport() {
+	return (init_resolveViewport = __esmMin((() => {
+		init_constants$1();
+		URL_VALUE_PATTERN = /^([0-9]{1,4})([a-z]{0,4})-([0-9]{1,4})([a-z]{0,4})$/;
+		normalizeGlobal$1 = (value, defaultIsRotated) => typeof value === "string" ? {
+			value,
+			isRotated: defaultIsRotated
+		} : {
+			value: value?.value,
+			isRotated: value?.isRotated ?? defaultIsRotated
+		};
+		resolveViewport = ({ globals, storyGlobals, userGlobals, options, lastSelectedOption, disable = false, viewMode }) => {
+			if (viewMode !== "story") return {
+				name: "Responsive",
+				type: "desktop",
+				width: "100%",
+				height: "100%",
+				value: RESPONSIVE_VIEWPORT_VALUE,
+				option: void 0,
+				isCustom: false,
+				isDefault: true,
+				isLocked: true,
+				isRotated: false
+			};
+			const global = normalizeGlobal$1(globals?.[PARAM_KEY]);
+			const userGlobal = normalizeGlobal$1(userGlobals?.[PARAM_KEY]);
+			const storyGlobal = normalizeGlobal$1(storyGlobals?.[PARAM_KEY]);
+			const storyHasViewport = PARAM_KEY in storyGlobals;
+			const primaryGlobal = storyHasViewport ? storyGlobal : userGlobal;
+			const secondaryGlobal = storyHasViewport ? userGlobal : storyGlobal;
+			const value = primaryGlobal?.value ?? secondaryGlobal?.value ?? global?.value;
+			const isRotated = primaryGlobal?.isRotated ?? secondaryGlobal?.isRotated ?? global?.isRotated ?? false;
+			const keys = Object.keys(options);
+			const isLocked = disable || "viewport" in storyGlobals || !keys.length;
+			const [match, vx, ux, vy, uy] = value?.match(URL_VALUE_PATTERN) || [];
+			if (match) {
+				const x = ux && ux !== "px" ? vx : Math.max(Number(vx), 40);
+				const y = uy && uy !== "px" ? vy : Math.max(Number(vy), 40);
+				const width = `${x}${ux === "pct" ? "%" : ux || "px"}`;
+				const height = `${y}${uy === "pct" ? "%" : uy || "px"}`;
+				const selection = lastSelectedOption ? options[lastSelectedOption] : void 0;
+				return {
+					name: selection?.name ?? "Custom",
+					type: selection?.type ?? "other",
+					width: isRotated ? height : width,
+					height: isRotated ? width : height,
+					value: match,
+					option: void 0,
+					isCustom: true,
+					isDefault: false,
+					isLocked,
+					isRotated
+				};
+			}
+			if (value && keys.length) {
+				const { name, styles, type = "other" } = options[value] ?? options[keys[0]];
+				return {
+					name,
+					type,
+					width: isRotated ? styles.height : styles.width,
+					height: isRotated ? styles.width : styles.height,
+					value,
+					option: value,
+					isCustom: false,
+					isDefault: false,
+					isLocked,
+					isRotated
+				};
+			}
+			return {
+				name: "Responsive",
+				type: "desktop",
+				width: "100%",
+				height: "100%",
+				value: RESPONSIVE_VIEWPORT_VALUE,
+				option: void 0,
+				isCustom: false,
+				isDefault: true,
+				isLocked,
+				isRotated: false
+			};
+		};
+	})))();
+}
+//#endregion
+//#region src/viewport/useViewport.ts
+var cycle, normalizeGlobal, useViewport;
+function init_useViewport() {
+	return (init_useViewport = __esmMin((() => {
+		init__storybook_global_react();
+		init_manager_api();
+		init_constants$1();
+		init_defaults();
+		init_resolveViewport();
+		cycle = (viewports, current, direction = 1) => {
+			const keys = Object.keys(viewports);
+			const nextIndex = (current ? keys.indexOf(current) : -1) + direction;
+			return nextIndex < 0 ? keys[keys.length - 1] : nextIndex >= keys.length ? keys[0] : keys[nextIndex];
+		};
+		normalizeGlobal = (value, defaultIsRotated) => typeof value === "string" ? {
+			value,
+			isRotated: defaultIsRotated
+		} : {
+			value: value?.value,
+			isRotated: value?.isRotated ?? defaultIsRotated
+		};
+		useViewport = () => {
+			const api = useStorybookApi();
+			const { viewMode } = api.getUrlState();
+			const lastSelectedOption = useRef();
+			const parameter = useParameter(PARAM_KEY);
+			const [globals, updateGlobals, storyGlobals, userGlobals] = useGlobals();
+			const { options = MINIMAL_VIEWPORTS, disable = false } = parameter || {};
+			const { name, type, width, height, value, option, isCustom, isDefault, isLocked, isRotated } = resolveViewport({
+				globals,
+				storyGlobals,
+				userGlobals,
+				options,
+				lastSelectedOption: lastSelectedOption.current,
+				disable,
+				viewMode
+			});
+			const update = useCallback((input) => updateGlobals({ [PARAM_KEY]: normalizeGlobal(input, false) }), [updateGlobals]);
+			const resize = useCallback((width, height) => {
+				const w = width.replace(/px$/, "").replace(/%$/, "pct");
+				const h = height.replace(/px$/, "").replace(/%$/, "pct");
+				const value = isRotated ? `${h}-${w}` : `${w}-${h}`;
+				update({
+					value,
+					isRotated
+				});
+			}, [update, isRotated]);
+			useEffect(() => {
+				if (!parameter) return;
+				if (option) {
+					if (Object.hasOwn(options, option)) lastSelectedOption.current = option;
+					else {
+						lastSelectedOption.current = void 0;
+						if (!("viewport" in storyGlobals)) update({
+							value: void 0,
+							isRotated: false
+						});
+					}
+				}
+			}, [
+				parameter,
+				storyGlobals,
+				options,
+				option,
+				update
+			]);
+			useEffect(() => {
+				api.setAddonShortcut(ADDON_ID, {
+					label: "Next viewport",
+					defaultShortcut: ["alt", "V"],
+					actionName: "next",
+					action: () => update({
+						value: cycle(options, lastSelectedOption.current),
+						isRotated
+					})
+				});
+				api.setAddonShortcut(ADDON_ID, {
+					label: "Previous viewport",
+					defaultShortcut: [
+						"alt",
+						"shift",
+						"V"
+					],
+					actionName: "previous",
+					action: () => update({
+						value: cycle(options, lastSelectedOption.current, -1),
+						isRotated
+					})
+				});
+				api.setAddonShortcut(ADDON_ID, {
+					label: "Reset viewport",
+					defaultShortcut: [
+						"alt",
+						"control",
+						"V"
+					],
+					actionName: "reset",
+					action: () => update({
+						value: void 0,
+						isRotated: false
+					})
+				});
+			}, [
+				api,
+				update,
+				options,
+				isRotated
+			]);
+			return useMemo(() => ({
+				name,
+				type,
+				width,
+				height,
+				value,
+				option,
+				isCustom,
+				isDefault,
+				isLocked,
+				isRotated,
+				options,
+				lastSelectedOption: lastSelectedOption.current,
+				resize,
+				reset: () => update({
+					value: void 0,
+					isRotated: false
+				}),
+				rotate: () => update({
+					value,
+					isRotated: !isRotated
+				}),
+				select: (value) => update({
+					value,
+					isRotated
+				})
+			}), [
+				name,
+				type,
+				width,
+				height,
+				value,
+				option,
+				isCustom,
+				isDefault,
+				isRotated,
+				isLocked,
+				options,
+				resize,
+				update
+			]);
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/constants/tags.ts
+var Tag, BUILT_IN_FILTERS, USER_TAG_FILTER;
+function init_tags() {
+	return (init_tags = __esmMin((() => {
+		Tag = {
+			/** Indicates that autodocs should be generated for this component */
+			AUTODOCS: "autodocs",
+			/** MDX documentation attached to a component's stories file */
+			ATTACHED_MDX: "attached-mdx",
+			/** Standalone MDX documentation not attached to stories */
+			UNATTACHED_MDX: "unattached-mdx",
+			/** Story has a play function */
+			PLAY_FN: "play-fn",
+			/** Story has a test function */
+			TEST_FN: "test-fn",
+			/** Development environment tag */
+			DEV: "dev",
+			/** Test environment tag */
+			TEST: "test",
+			/** Manifest generation tag */
+			MANIFEST: "manifest"
+		};
+		BUILT_IN_FILTERS = {
+			_docs: (entry, excluded) => excluded ? entry.type !== "docs" : entry.type === "docs",
+			_play: (entry, excluded) => excluded ? entry.type !== "story" || !entry.tags?.includes(Tag.PLAY_FN) : entry.type === "story" && !!entry.tags?.includes(Tag.PLAY_FN),
+			_test: (entry, excluded) => excluded ? entry.type !== "story" || entry.subtype !== "test" : entry.type === "story" && entry.subtype === "test"
+		};
+		USER_TAG_FILTER = (tag) => (entry, excluded) => excluded ? !entry.tags?.includes(tag) : !!entry.tags?.includes(tag);
+	})))();
+}
+//#endregion
+//#region src/shared/utils/story-index-filters.ts
+var getActiveFilterCount;
+function init_story_index_filters() {
+	return (init_story_index_filters = __esmMin((() => {
+		getActiveFilterCount = ({ includedTagFilters, excludedTagFilters, includedStatusFilters, excludedStatusFilters }) => (includedTagFilters?.length ?? 0) + (excludedTagFilters?.length ?? 0) + (includedStatusFilters?.length ?? 0) + (excludedStatusFilters?.length ?? 0);
+	})))();
+}
+//#endregion
+//#region src/storybook-error.ts
+function parseErrorCode({ code, category }) {
+	return `SB_${category}_${String(code).padStart(4, "0")}`;
+}
+function appendErrorRef(url) {
+	if (/^(?!.*storybook\.js\.org)|[?&]ref=error\b/.test(url)) return url;
+	try {
+		const urlObj = new URL(url);
+		urlObj.searchParams.set("ref", "error");
+		return urlObj.toString();
+	} catch {
+		return url;
+	}
+}
+var StorybookError;
+function init_storybook_error() {
+	return (init_storybook_error = __esmMin((() => {
+		StorybookError = class StorybookError extends Error {
+			get fullErrorCode() {
+				return parseErrorCode({
+					code: this.code,
+					category: this.category
+				});
+			}
+			/** Overrides the default `Error.name` property in the format: SB_<CATEGORY>_<CODE>. */
+			get name() {
+				const errorName = this._name || this.constructor.name;
+				return `${this.fullErrorCode} (${errorName})`;
+			}
+			set name(name) {
+				this._name = name;
+			}
+			constructor(props) {
+				super(StorybookError.getFullMessage(props), props.cause === void 0 ? void 0 : { cause: props.cause });
+				this.data = {};
+				this.fromStorybook = true;
+				this.isHandledError = false;
+				this.subErrors = [];
+				this.category = props.category;
+				this.documentation = props.documentation ?? false;
+				this.code = props.code;
+				this.isHandledError = props.isHandledError ?? false;
+				this.agentFacing = props.agentFacing ?? false;
+				this.name = props.name;
+				this.subErrors = props.subErrors ?? [];
+			}
+			/** Generates the error message along with additional documentation link (if applicable). */
+			static getFullMessage({ documentation, code, category, message }) {
+				let page;
+				if (documentation === true) page = `https://storybook.js.org/error/${parseErrorCode({
+					code,
+					category
+				})}?ref=error`;
+				else if (typeof documentation === "string") page = appendErrorRef(documentation);
+				else if (Array.isArray(documentation)) page = `\n${documentation.map((doc) => `\t- ${appendErrorRef(doc)}`).join("\n")}`;
+				return `${message}${page != null ? `\n\nMore info: ${page}\n` : ""}`;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/server-errors.ts
+var StatusTypeIdMismatchError;
+function init_server_errors() {
+	return (init_server_errors = __esmMin((() => {
+		init_storybook_error();
+		StatusTypeIdMismatchError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "StatusTypeIdMismatchError",
+					category: "CORE-SERVER",
+					code: 16,
+					message: `Status has typeId "${data.status.typeId}" but was added to store with typeId "${data.typeId}". Full status: ${JSON.stringify(data.status, null, 2)}`
+				});
+				this.data = data;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/status-store/index.ts
+function countStatusesByValue(allStatuses) {
+	const counts = {};
+	for (const statusByTypeId of Object.values(allStatuses)) for (const status of Object.values(statusByTypeId)) counts[status.value] = (counts[status.value] ?? 0) + 1;
+	return counts;
+}
+function createStatusStore({ universalStatusStore, useUniversalStore, environment }) {
+	const fullStatusStore = {
+		getAll() {
+			return universalStatusStore.getState();
+		},
+		set(statuses) {
+			universalStatusStore.setState((state) => {
+				const newState = { ...state };
+				for (const status of statuses) {
+					const { storyId, typeId } = status;
+					newState[storyId] = {
+						...newState[storyId] ?? {},
+						[typeId]: status
+					};
+				}
+				return newState;
+			});
+		},
+		onAllStatusChange(listener) {
+			return universalStatusStore.onStateChange((state, prevState) => {
+				listener(state, prevState);
+			});
+		},
+		onSelect(listener) {
+			return universalStatusStore.subscribe(StatusStoreEventType.SELECT, (event) => {
+				listener(event.payload);
+			});
+		},
+		selectStatuses: (statuses) => {
+			universalStatusStore.send({
+				type: StatusStoreEventType.SELECT,
+				payload: statuses
+			});
+		},
+		unset(storyIds) {
+			if (!storyIds) {
+				universalStatusStore.setState({});
+				return;
+			}
+			universalStatusStore.setState((state) => {
+				const newState = { ...state };
+				for (const storyId of storyIds) delete newState[storyId];
+				return newState;
+			});
+		},
+		typeId: void 0
+	};
+	const getStatusStoreByTypeId = (typeId) => ({
+		getAll: fullStatusStore.getAll,
+		set(statuses) {
+			universalStatusStore.setState((state) => {
+				const newState = { ...state };
+				for (const status of statuses) {
+					const { storyId } = status;
+					if (status.typeId !== typeId) switch (environment) {
+						case "server": throw new StatusTypeIdMismatchError({
+							status,
+							typeId
+						});
+						case "manager": throw new StatusTypeIdMismatchError$1({
+							status,
+							typeId
+						});
+						default: throw new StatusTypeIdMismatchError$2({
+							status,
+							typeId
+						});
+					}
+					newState[storyId] = {
+						...newState[storyId] ?? {},
+						[typeId]: status
+					};
+				}
+				return newState;
+			});
+		},
+		onAllStatusChange: fullStatusStore.onAllStatusChange,
+		onSelect(listener) {
+			return universalStatusStore.subscribe(StatusStoreEventType.SELECT, (event) => {
+				if (event.payload.some((status) => status.typeId === typeId)) listener(event.payload);
+			});
+		},
+		unset(storyIds) {
+			universalStatusStore.setState((state) => {
+				const newState = { ...state };
+				for (const storyId in newState) if (newState[storyId]?.[typeId] && (!storyIds || storyIds?.includes(storyId))) {
+					const { [typeId]: omittedStatus, ...storyStatusesWithoutTypeId } = newState[storyId];
+					newState[storyId] = storyStatusesWithoutTypeId;
+				}
+				return newState;
+			});
+		},
+		typeId
+	});
+	if (!useUniversalStore) return {
+		getStatusStoreByTypeId,
+		fullStatusStore,
+		universalStatusStore
+	};
+	return {
+		getStatusStoreByTypeId,
+		fullStatusStore,
+		universalStatusStore,
+		useStatusStore: (selector) => useUniversalStore(universalStatusStore, selector)[0]
+	};
+}
+var statusValueShortName, statusValueDescription, UNIVERSAL_STATUS_STORE_OPTIONS, StatusStoreEventType;
+function init_status_store() {
+	return (init_status_store = __esmMin((() => {
+		init_manager_errors();
+		init_preview_errors();
+		init_server_errors();
+		statusValueShortName = (value) => {
+			if (value === "status-value:affected") return "related";
+			return value.slice(13);
+		};
+		statusValueDescription = (value) => ({
+			"status-value:pending": "Stories with pending status",
+			"status-value:success": "Stories with passing tests",
+			"status-value:new": "Newly added stories",
+			"status-value:modified": "Stories closely linked to code changes",
+			"status-value:affected": "Stories likely to be affected by code changes",
+			"status-value:reviewing": "Stories included in the active review",
+			"status-value:warning": "Stories with warnings",
+			"status-value:error": "Stories with failing tests",
+			"status-value:unknown": "Stories with unknown status"
+		})[value];
+		UNIVERSAL_STATUS_STORE_OPTIONS = {
+			id: "@aussieljk/forkbook/status",
+			leader: true,
+			initialState: {}
+		};
+		StatusStoreEventType = { SELECT: "select" };
+	})))();
+}
+//#endregion
+//#region src/shared/universal-store/first-party-store-ids.ts
+var FIRST_PARTY_STORE_IDS, isFirstPartyStoreId;
+function init_first_party_store_ids() {
+	return (init_first_party_store_ids = __esmMin((() => {
+		FIRST_PARTY_STORE_IDS = /* @__PURE__ */ new Set([
+			"@aussieljk/forkbook/status",
+			"@aussieljk/forkbook/test-provider",
+			"@aussieljk/forkbook/test"
+		]);
+		isFirstPartyStoreId = (id) => FIRST_PARTY_STORE_IDS.has(id);
+	})))();
+}
+//#endregion
+//#region src/shared/universal-store/instances.ts
+var instances;
+function init_instances() {
+	return (init_instances = __esmMin((() => {
+		instances = /* @__PURE__ */ new Map();
+	})))();
+}
+//#endregion
+//#region src/shared/universal-store/index.ts
+var CHANNEL_EVENT_PREFIX, ProgressState, UniversalStore;
+function init_universal_store() {
+	return (init_universal_store = __esmMin((() => {
+		init_esm();
+		init_manager_errors();
+		init_first_party_store_ids();
+		init_instances();
+		CHANNEL_EVENT_PREFIX = "UNIVERSAL_STORE:";
+		ProgressState = {
+			PENDING: "PENDING",
+			RESOLVED: "RESOLVED",
+			REJECTED: "REJECTED"
+		};
+		UniversalStore = class UniversalStore {
+			static {
+				this.ActorType = {
+					LEADER: "LEADER",
+					FOLLOWER: "FOLLOWER"
+				};
+			}
+			static {
+				this.Environment = {
+					SERVER: "SERVER",
+					MANAGER: "MANAGER",
+					PREVIEW: "PREVIEW",
+					UNKNOWN: "UNKNOWN",
+					MOCK: "MOCK"
+				};
+			}
+			/** The environment this realm was prepared as, or `undefined` before `__prepare`. */
+			static get preparedEnvironment() {
+				return UniversalStore.preparation.environment;
+			}
+			static {
+				this.InternalEventType = {
+					EXISTING_STATE_REQUEST: "__EXISTING_STATE_REQUEST",
+					EXISTING_STATE_RESPONSE: "__EXISTING_STATE_RESPONSE",
+					SET_STATE: "__SET_STATE",
+					LEADER_CREATED: "__LEADER_CREATED",
+					FOLLOWER_CREATED: "__FOLLOWER_CREATED"
+				};
+			}
+			static {
+				this.Status = {
+					UNPREPARED: "UNPREPARED",
+					SYNCING: "SYNCING",
+					READY: "READY",
+					ERROR: "ERROR"
+				};
+			}
+			static {
+				this.isInternalConstructing = false;
+			}
+			static {
+				UniversalStore.setupPreparationPromise();
+			}
+			static setupPreparationPromise() {
+				let resolveRef;
+				let rejectRef;
+				const promise = new Promise((resolve, reject) => {
+					resolveRef = (args) => {
+						resolve(args);
+					};
+					rejectRef = (...args) => {
+						reject(args);
+					};
+				});
+				UniversalStore.preparation = {
+					resolve: resolveRef,
+					reject: rejectRef,
+					promise
+				};
+			}
+			/** The actor object representing the store instance with a unique ID and a type */
+			get actor() {
+				return Object.freeze({
+					id: this.actorId,
+					type: this.actorType,
+					environment: this.environment ?? UniversalStore.Environment.UNKNOWN
+				});
+			}
+			/**
+			* The current state of the store, that signals both if the store is prepared by Forkbook and
+			* also - in the case of a follower - if the state has been synced with the leader's state.
+			*/
+			get status() {
+				if (!this.channel || !this.environment) return UniversalStore.Status.UNPREPARED;
+				switch (this.syncing?.state) {
+					case ProgressState.PENDING:
+					case void 0: return UniversalStore.Status.SYNCING;
+					case ProgressState.REJECTED: return UniversalStore.Status.ERROR;
+					case ProgressState.RESOLVED:
+					default: return UniversalStore.Status.READY;
+				}
+			}
+			/**
+			* A promise that resolves when the store is fully ready. A leader will be ready when the store
+			* has been prepared by Forkbook, which is almost instantly.
+			*
+			* A follower will be ready when the state has been synced with the leader's state, within a few
+			* hundred milliseconds.
+			*/
+			untilReady() {
+				const preparation = this.channel && this.environment ? Promise.resolve() : UniversalStore.preparation.promise;
+				return Promise.all([preparation, this.syncing?.promise]);
+			}
+			constructor(options, environmentOverrides) {
+				this.debugging = false;
+				this.listeners = /* @__PURE__ */ new Map([["*", /* @__PURE__ */ new Set()]]);
+				this.getState = () => {
+					this.debug("getState", { state: this.state });
+					return this.state;
+				};
+				this.subscribe = (eventTypeOrListener, maybeListener) => {
+					const subscribesToAllEvents = typeof eventTypeOrListener === "function";
+					const eventType = subscribesToAllEvents ? "*" : eventTypeOrListener;
+					const listener = subscribesToAllEvents ? eventTypeOrListener : maybeListener;
+					this.debug("subscribe", {
+						eventType,
+						listener
+					});
+					if (!listener) throw new TypeError(`Missing first subscribe argument, or second if first is the event type, when subscribing to a UniversalStore with id '${this.id}'`);
+					if (!this.listeners.has(eventType)) this.listeners.set(eventType, /* @__PURE__ */ new Set());
+					this.listeners.get(eventType).add(listener);
+					return () => {
+						this.debug("unsubscribe", {
+							eventType,
+							listener
+						});
+						if (!this.listeners.has(eventType)) return;
+						this.listeners.get(eventType).delete(listener);
+						if (this.listeners.get(eventType)?.size === 0) this.listeners.delete(eventType);
+					};
+				};
+				this.send = (event) => {
+					this.debug("send", { event });
+					if (this.status !== UniversalStore.Status.READY) throw new TypeError(dedent`Cannot send event before store is ready. You can get the current status with store.status,
+        or await store.readyPromise to wait for the store to be ready before sending events.
+        ${JSON.stringify({
+						event,
+						id: this.id,
+						actor: this.actor,
+						environment: this.environment
+					}, null, 2)}`);
+					this.emitToListeners(event, { actor: this.actor });
+					this.emitToChannel(event, { actor: this.actor });
+				};
+				this.debugging = options.debug ?? false;
+				if (!UniversalStore.isInternalConstructing) throw new TypeError("UniversalStore is not constructable - use UniversalStore.create() instead");
+				UniversalStore.isInternalConstructing = false;
+				this.id = options.id;
+				this.actorId = Date.now().toString(36) + Math.random().toString(36).substring(2);
+				this.actorType = options.leader ? UniversalStore.ActorType.LEADER : UniversalStore.ActorType.FOLLOWER;
+				this.state = options.initialState;
+				this.channelEventName = `${CHANNEL_EVENT_PREFIX}${this.id}`;
+				this.debug("constructor", {
+					options,
+					environmentOverrides,
+					channelEventName: this.channelEventName
+				});
+				if (this.actor.type === UniversalStore.ActorType.LEADER) this.syncing = {
+					state: ProgressState.RESOLVED,
+					promise: Promise.resolve()
+				};
+				else {
+					let syncingResolve;
+					let syncingReject;
+					const syncingPromise = new Promise((resolve, reject) => {
+						syncingResolve = () => {
+							if (this.syncing.state !== ProgressState.PENDING) return;
+							this.syncing.state = ProgressState.RESOLVED;
+							resolve();
+						};
+						syncingReject = (reason) => {
+							if (this.syncing.state !== ProgressState.PENDING) return;
+							this.syncing.state = ProgressState.REJECTED;
+							reject(reason);
+						};
+					});
+					this.syncing = {
+						state: ProgressState.PENDING,
+						promise: syncingPromise,
+						resolve: syncingResolve,
+						reject: syncingReject
+					};
+				}
+				this.getState = this.getState.bind(this);
+				this.setState = this.setState.bind(this);
+				this.subscribe = this.subscribe.bind(this);
+				this.onStateChange = this.onStateChange.bind(this);
+				this.send = this.send.bind(this);
+				this.emitToChannel = this.emitToChannel.bind(this);
+				this.prepareThis = this.prepareThis.bind(this);
+				this.emitToListeners = this.emitToListeners.bind(this);
+				this.handleChannelEvents = this.handleChannelEvents.bind(this);
+				this.debug = this.debug.bind(this);
+				this.channel = environmentOverrides?.channel ?? UniversalStore.preparation.channel;
+				this.environment = environmentOverrides?.environment ?? UniversalStore.preparation.environment;
+				if (this.channel && this.environment) {
+					if (!environmentOverrides) UniversalStore.preparation.resolve({
+						channel: this.channel,
+						environment: this.environment
+					});
+					this.prepareThis({
+						channel: this.channel,
+						environment: this.environment
+					});
+				} else UniversalStore.preparation.promise.then(this.prepareThis);
+			}
+			/** Creates a new instance of UniversalStore */
+			static create(options) {
+				if (!options || typeof options?.id !== "string") throw new TypeError("id is required and must be a string, when creating a UniversalStore");
+				if (!isFirstPartyStoreId(options.id)) throw new TypeError(`UniversalStore is internal to Forkbook and cannot create a store with id "${options.id}"`);
+				if (options.debug) console.debug(dedent`[UniversalStore]
+        create`, { options });
+				const existing = instances.get(options.id);
+				if (existing) {
+					console.warn(dedent`UniversalStore with id "${options.id}" already exists in this environment, re-using existing.
+        You should reuse the existing instance instead of trying to create a new one.`);
+					return existing;
+				}
+				UniversalStore.isInternalConstructing = true;
+				const store = new UniversalStore(options);
+				instances.set(options.id, store);
+				return store;
+			}
+			/**
+			* Used by Forkbook to set the channel for all instances of UniversalStore in the given
+			* environment.
+			*
+			* @internal
+			*/
+			static __prepare(channel, environment) {
+				UniversalStore.preparation.channel = channel;
+				UniversalStore.preparation.environment = environment;
+				UniversalStore.preparation.resolve({
+					channel,
+					environment
+				});
+			}
+			/**
+			* Updates the store's state
+			*
+			* Either a new state or a state updater function can be passed to the method.
+			*/
+			setState(updater) {
+				const previousState = this.state;
+				const newState = typeof updater === "function" ? updater(previousState) : updater;
+				this.debug("setState", {
+					newState,
+					previousState,
+					updater
+				});
+				if (this.status !== UniversalStore.Status.READY) throw new TypeError(dedent`Cannot set state before store is ready. You can get the current status with store.status,
+        or await store.readyPromise to wait for the store to be ready before sending events.
+        ${JSON.stringify({
+					newState,
+					id: this.id,
+					actor: this.actor,
+					environment: this.environment
+				}, null, 2)}`);
+				this.state = newState;
+				const event = {
+					type: UniversalStore.InternalEventType.SET_STATE,
+					payload: {
+						state: newState,
+						previousState
+					}
+				};
+				this.emitToChannel(event, { actor: this.actor });
+				this.emitToListeners(event, { actor: this.actor });
+			}
+			/**
+			* Subscribes to state changes
+			*
+			* @returns Unsubscribe function
+			*/
+			onStateChange(listener) {
+				this.debug("onStateChange", { listener });
+				return this.subscribe(UniversalStore.InternalEventType.SET_STATE, ({ payload }, eventInfo) => {
+					listener(payload.state, payload.previousState, eventInfo);
+				});
+			}
+			emitToChannel(event, eventInfo) {
+				this.debug("emitToChannel", {
+					event,
+					eventInfo,
+					channel: !!this.channel
+				});
+				this.channel?.emit(this.channelEventName, {
+					event,
+					eventInfo
+				});
+			}
+			prepareThis({ channel, environment }) {
+				this.channel = channel;
+				this.environment = environment;
+				this.debug("prepared", {
+					channel: !!channel,
+					environment
+				});
+				this.channel.on(this.channelEventName, this.handleChannelEvents);
+				if (this.actor.type === UniversalStore.ActorType.LEADER) this.emitToChannel({ type: UniversalStore.InternalEventType.LEADER_CREATED }, { actor: this.actor });
+				else {
+					this.emitToChannel({ type: UniversalStore.InternalEventType.FOLLOWER_CREATED }, { actor: this.actor });
+					this.emitToChannel({ type: UniversalStore.InternalEventType.EXISTING_STATE_REQUEST }, { actor: this.actor });
+					setTimeout(() => {
+						this.syncing.reject(new UniversalStoreFollowerTimeoutError(this.id));
+					}, 1e3);
+				}
+			}
+			emitToListeners(event, eventInfo) {
+				const eventTypeListeners = this.listeners.get(event.type);
+				const everythingListeners = this.listeners.get("*");
+				this.debug("emitToListeners", {
+					event,
+					eventInfo,
+					eventTypeListeners,
+					everythingListeners
+				});
+				[...eventTypeListeners ?? [], ...everythingListeners ?? []].forEach((listener) => listener(event, eventInfo));
+			}
+			handleChannelEvents(channelEvent) {
+				const { event, eventInfo } = channelEvent;
+				if ([eventInfo.actor.id, eventInfo.forwardingActor?.id].includes(this.actor.id)) {
+					this.debug("handleChannelEvents: Ignoring event from self", { channelEvent });
+					return;
+				} else if (this.syncing?.state === ProgressState.PENDING && event.type !== UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE) {
+					this.debug("handleChannelEvents: Ignoring event while syncing", { channelEvent });
+					return;
+				}
+				this.debug("handleChannelEvents", { channelEvent });
+				if (this.actor.type === UniversalStore.ActorType.LEADER) {
+					let shouldForwardEvent = true;
+					switch (event.type) {
+						case UniversalStore.InternalEventType.EXISTING_STATE_REQUEST:
+							shouldForwardEvent = false;
+							const responseEvent = {
+								type: UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE,
+								payload: this.state
+							};
+							this.debug("handleChannelEvents: responding to existing state request", { responseEvent });
+							this.emitToChannel(responseEvent, { actor: this.actor });
+							this.emitToListeners(responseEvent, { actor: this.actor });
+							break;
+						case UniversalStore.InternalEventType.LEADER_CREATED:
+							shouldForwardEvent = false;
+							this.syncing.state = ProgressState.REJECTED;
+							this.debug("handleChannelEvents: erroring due to second leader being created", { event });
+							console.error(dedent`Detected multiple UniversalStore leaders created with the same id "${this.id}".
+            Only one leader can exists at a time, your stores are now in an invalid state.
+            Leaders detected:
+            this: ${JSON.stringify(this.actor, null, 2)}
+            other: ${JSON.stringify(eventInfo.actor, null, 2)}`);
+					}
+					if (shouldForwardEvent) {
+						this.debug("handleChannelEvents: forwarding event", { channelEvent });
+						this.emitToChannel(event, {
+							actor: eventInfo.actor,
+							forwardingActor: this.actor
+						});
+					}
+				}
+				if (this.actor.type === UniversalStore.ActorType.FOLLOWER) switch (event.type) {
+					case UniversalStore.InternalEventType.EXISTING_STATE_RESPONSE:
+						this.debug("handleChannelEvents: Setting state from leader's existing state response", { event });
+						if (this.syncing?.state !== ProgressState.PENDING) break;
+						this.syncing.resolve?.();
+						const setStateEvent = {
+							type: UniversalStore.InternalEventType.SET_STATE,
+							payload: {
+								state: event.payload,
+								previousState: this.state
+							}
+						};
+						this.state = event.payload;
+						this.emitToListeners(setStateEvent, eventInfo);
+				}
+				switch (event.type) {
+					case UniversalStore.InternalEventType.SET_STATE:
+						this.debug("handleChannelEvents: Setting state", { event });
+						this.state = event.payload.state;
+				}
+				this.emitToListeners(event, { actor: eventInfo.actor });
+			}
+			debug(message, data) {
+				if (this.debugging) console.debug(dedent`[UniversalStore::${this.id}::${this.environment ?? UniversalStore.Environment.UNKNOWN}]
+        ${message}`, JSON.stringify({
+					data,
+					actor: this.actor,
+					state: this.state,
+					status: this.status
+				}, null, 2));
+			}
+			/**
+			* Used to reset the static fields of the UniversalStore class when cleaning up tests
+			*
+			* @internal
+			*/
+			static __reset() {
+				UniversalStore.preparation.reject(/* @__PURE__ */ new Error("reset"));
+				UniversalStore.setupPreparationPromise();
+				UniversalStore.isInternalConstructing = false;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/shared/universal-store/use-universal-store-manager.ts
+var useUniversalStore;
+function init_use_universal_store_manager() {
+	return (init_use_universal_store_manager = __esmMin((() => {
+		init__storybook_global_react();
+		init_isEqual();
+		useUniversalStore = (universalStore, selector) => {
+			const snapshotRef = useRef(selector ? selector(universalStore.getState()) : universalStore.getState());
+			const subscribe = useCallback((listener) => universalStore.onStateChange((state, previousState) => {
+				if (!selector) {
+					snapshotRef.current = state;
+					listener();
+					return;
+				}
+				const selectedState = selector(state);
+				const selectedPreviousState = selector(previousState);
+				if (!isEqual(selectedState, selectedPreviousState)) {
+					snapshotRef.current = selectedState;
+					listener();
+				}
+			}), [universalStore, selector]);
+			const getSnapshot = useCallback(() => {
+				const currentState = universalStore.getState();
+				const selectedState = selector ? selector(currentState) : currentState;
+				if (isEqual(selectedState, snapshotRef.current)) return snapshotRef.current;
+				snapshotRef.current = selectedState;
+				return snapshotRef.current;
+			}, [universalStore, selector]);
+			return [useSyncExternalStore(subscribe, getSnapshot), universalStore.setState];
+		};
+	})))();
+}
+//#endregion
+export { useCopyButton as A, iframeResizeDimensionsEqual as C, REVIEW_NAMESPACE as D, REVIEW_EVENTS as E, ToolbarManager as F, init_ToolbarManager as I, TOOLBAR_ID as L, init_routes as M, isReviewCollectionStoryRoute as N, init_events as O, isReviewSummaryPath as P, init_constants as R, hasFixedViewportDimensions as S, parseIframeResizeMessage as T, init_tags as _, UNIVERSAL_STATUS_STORE_OPTIONS as a, init_resolveViewport as b, init_status_store as c, StorybookError as d, init_storybook_error as f, USER_TAG_FILTER as g, BUILT_IN_FILTERS as h, init_universal_store as i, REVIEW_COLLECTION_QUERY_PARAM as j, init_useCopyButton as k, statusValueDescription as l, init_story_index_filters as m, useUniversalStore as n, countStatusesByValue as o, getActiveFilterCount as p, UniversalStore as r, createStatusStore as s, init_use_universal_store_manager as t, statusValueShortName as u, init_useViewport as v, init_iframe_resize as w, IFRAME_RESIZE_REQUEST_CONTEXT as x, useViewport as y };