@scayle/storefront-devtools 0.2.0-alpha.1

package/dist/inertia/client/index.mjs

@@ -0,0 +1,694 @@
+import { i as e, r as t, t as n } from "../../_chunks/diff-DzJ5arJj.mjs";
+import { a as r, i, n as a, o, r as s } from "../../_chunks/redact-DmIF-iyk.mjs";
+//#region src/inertia/core/url.ts
+function c(e) {
+	try {
+		let t = new URL(e, "http://localhost");
+		return t.pathname + t.search;
+	} catch {
+		return e;
+	}
+}
+//#endregion
+//#region src/inertia/core/diagnostics.ts
+function l(e) {
+	return e.type === "redirect" && e.status === 409 ? {
+		id: "version-mismatch",
+		severity: "warning",
+		message: "Asset version mismatch, full page reload",
+		docsUrl: "https://inertiajs.com/the-protocol#asset-versioning"
+	} : null;
+}
+function u(e) {
+	return e.interrupted ? {
+		id: "visit-interrupted",
+		severity: "info",
+		message: "Interrupted by a newer visit"
+	} : e.cancelled ? {
+		id: "visit-cancelled",
+		severity: "info",
+		message: "Visit was cancelled"
+	} : null;
+}
+function d(e) {
+	if (e.only?.length && e.page?.props) {
+		let t = Object.keys(e.page.props), n = e.only.filter((e) => !t.includes(e));
+		if (n.length) return {
+			id: "partial-prop-missing",
+			severity: "warning",
+			message: `Partial reload: '${n.join("', '")}' requested but missing from response`,
+			docsUrl: "https://inertiajs.com/partial-reloads"
+		};
+	}
+	return null;
+}
+function f(e) {
+	return e.only && e.only.length > 0 && !e.only.includes("errors") && (e.status === 422 || e.events.some((e) => e.name === "inertia:error")) ? {
+		id: "errors-filtered",
+		severity: "warning",
+		message: "Validation errors may be filtered: 'only' option doesn't include 'errors'",
+		docsUrl: "https://inertiajs.com/partial-reloads"
+	} : null;
+}
+function p(e) {
+	return e.type === "deferred" && e.error ? {
+		id: "deferred-failed",
+		severity: "error",
+		message: "Deferred props failed to load",
+		docsUrl: "https://inertiajs.com/deferred-props"
+	} : null;
+}
+function m(e) {
+	if (e.type === "client" && e.method === "REPLACE") return {
+		id: "history-replace",
+		severity: "info",
+		message: "History replaced (same URL)",
+		docsUrl: "https://inertiajs.com/manual-visits#browser-history"
+	};
+	if (e.visitOptions?.replace === !0) {
+		let t = e.previousPage?.url;
+		return t && c(t) === c(e.url) ? {
+			id: "history-replace-same-url",
+			severity: "info",
+			message: "History replaced (same URL)",
+			docsUrl: "https://inertiajs.com/manual-visits#browser-history"
+		} : {
+			id: "history-replace",
+			severity: "info",
+			message: "History replace mode",
+			docsUrl: "https://inertiajs.com/manual-visits#browser-history"
+		};
+	}
+	return null;
+}
+var h = [
+	l,
+	u,
+	d,
+	f,
+	p,
+	m
+];
+function g(e) {
+	let t = [];
+	for (let n of h) {
+		let r = n(e);
+		r && t.push(r);
+	}
+	return t;
+}
+//#endregion
+//#region src/inertia/core/correlator.ts
+var _ = 10, v = 2e3, y = class {
+	nextVisitId = 1;
+	records = /* @__PURE__ */ new Map();
+	sortedRecords = [];
+	maxRecords;
+	fingerprintMap = /* @__PURE__ */ new Map();
+	recordByInertiaVisitId = /* @__PURE__ */ new Map();
+	pendingPrefetch = null;
+	activeVisitId = null;
+	lastPage = null;
+	pendingNetwork = [];
+	_evictedCount = 0;
+	constructor(e = 200) {
+		this.maxRecords = e;
+	}
+	processEvent(e) {
+		let { name: t, detail: n, timestamp: r } = e;
+		switch (t) {
+			case "inertia:before": return this.handleBefore(e, n, r);
+			case "inertia:start": return this.handleStart(e, n);
+			case "inertia:finish": return this.handleFinish(e, n, r);
+			case "inertia:cancel": return this.handleCancel(e);
+			case "inertia:navigate": return this.handleNavigate(e, n);
+			case "inertia:beforeUpdate": return this.handleBeforeUpdate(e, n);
+			default: return this.handleGenericEvent(e, n);
+		}
+	}
+	getRequests() {
+		return this.sortedRecords;
+	}
+	getRequest(e) {
+		return this.records.get(e);
+	}
+	getCurrentPage() {
+		return this.lastPage;
+	}
+	get evictedCount() {
+		return this._evictedCount;
+	}
+	hasRequestWithUrl(e) {
+		let t = c(e);
+		return this.sortedRecords.some((e) => c(e.url) === t);
+	}
+	processClientVisit(t, n, r) {
+		let i = this.nextVisitId++, a = performance.now(), o = {
+			visitId: i,
+			type: "client",
+			method: t === "push" ? "PUSH" : "REPLACE",
+			url: n.url ?? "/",
+			startedAt: a,
+			finishedAt: a,
+			duration: 0,
+			events: [],
+			features: e(n),
+			diagnostics: [],
+			cancelled: !1,
+			interrupted: !1,
+			completed: !0,
+			page: n,
+			previousPage: r
+		};
+		return this.insertRecord(o), this.lastPage = n, this.activeVisitId = i, o;
+	}
+	clear() {
+		this.records.clear(), this.sortedRecords = [], this.fingerprintMap.clear(), this.recordByInertiaVisitId.clear(), this.pendingPrefetch = null, this.pendingNetwork = [], this._evictedCount = 0, this.activeVisitId = null, this.nextVisitId = 1;
+	}
+	linkNetworkTiming(e) {
+		let t = this.findNetworkMatch(e);
+		return t ? (t.network = e, t) : (this.pendingNetwork.push(e), this.pendingNetwork.length > _ && this.pendingNetwork.shift(), null);
+	}
+	attachRequestHeaders(e, t) {
+		let n = this.recordByInertiaVisitId.get(e);
+		return n ? (n.headers = t, n) : null;
+	}
+	attachResponseData(e, t) {
+		let n = this.recordByInertiaVisitId.get(e);
+		return n ? (n.responseHeaders = t.headers, n.responseProps = t.props, n) : null;
+	}
+	drainPendingNetwork(e) {
+		let t = this.pendingNetwork.findLastIndex((t) => this.networkMatchesVisit(t, e));
+		t !== -1 && (e.network = this.pendingNetwork[t], this.pendingNetwork.splice(t, 1));
+	}
+	findNetworkMatch(e) {
+		return this.sortedRecords.findLast((t) => !t.network && this.networkMatchesVisit(e, t)) ?? null;
+	}
+	networkMatchesVisit(e, t) {
+		return !(c(e.url) !== c(t.url) || e.startedAt < t.startedAt - v || t.finishedAt && e.startedAt > t.finishedAt + v);
+	}
+	handleBefore(e, t, n) {
+		let r = this.extractVisit(t), i = this.visitFingerprint(r);
+		if (r && r.prefetch) return this.pendingPrefetch = {
+			event: e,
+			timestamp: n,
+			url: this.extractUrl(r),
+			fingerprint: i
+		}, null;
+		let a = this.nextVisitId++, o = (r?.method ?? "GET").toUpperCase(), s = this.extractUrl(r), c = r != null && this.isDeferredReload(r), l = c ? "deferred" : this.classifyVisitType(r), u;
+		c ? u = this.findNestingParentVisitId(s) : l === "partial" && (u = this.findNestingParentVisitId());
+		let d = r?.only?.length ? r.only : void 0, f = r?.except?.length ? r.except : void 0, p = r ? this.extractVisitOptions(r) : void 0, m = {
+			visitId: a,
+			parentVisitId: u,
+			type: l,
+			method: o,
+			url: s,
+			only: d,
+			except: f,
+			startedAt: n,
+			events: [e],
+			features: [],
+			diagnostics: [],
+			cancelled: !1,
+			interrupted: !1,
+			completed: !1,
+			previousPage: this.lastPage ?? void 0,
+			visitOptions: p,
+			inertiaVisitId: r?.id
+		};
+		return this.insertRecord(m), this.pushFingerprint(i, a), r?.id && this.recordByInertiaVisitId.set(r.id, m), c || (this.activeVisitId = a), m;
+	}
+	handleStart(e, t) {
+		let n = this.extractVisit(t);
+		if (this.pendingPrefetch && n && this.visitFingerprint(n) === this.pendingPrefetch.fingerprint) {
+			let t = this.pendingPrefetch;
+			return this.pendingPrefetch = null, this.createPrefetchRecord(n, t.event, e, t.timestamp);
+		}
+		let r = this.resolveByFingerprint(e) ?? this.resolveByActiveId();
+		return r && r.events.push(e), r;
+	}
+	handleFinish(e, n, r) {
+		let i = this.resolveByFingerprint(e) ?? this.resolveByActiveId();
+		if (!i) return null;
+		i.events.push(e), i.finishedAt = r, i.duration = r - i.startedAt;
+		let a = this.extractVisit(n);
+		if (a && (i.completed = !!a.completed, i.cancelled = !!a.cancelled, i.interrupted = !!a.interrupted), i.network || this.drainPendingNetwork(i), i.type === "deferred" && (!i.page && this.lastPage && (i.page = this.lastPage, i.features = t(i, this.lastPage)), !i.previousPage && i.parentVisitId)) {
+			let e = this.records.get(i.parentVisitId);
+			e?.page && (i.previousPage = e.page);
+		}
+		return i.diagnostics = g(i), i;
+	}
+	handleCancel(e) {
+		let t = this.resolveByFingerprint(e) ?? this.resolveByActiveId();
+		return t ? (t.events.push(e), t.cancelled = !0, t) : null;
+	}
+	handleNavigate(e, n) {
+		let r = n.page;
+		r && (this.lastPage = r);
+		let i = this.resolveByActiveId();
+		if (!i && r) {
+			let t = this.nextVisitId++;
+			i = {
+				visitId: t,
+				type: "full",
+				method: "GET",
+				url: r.url ?? "/",
+				startedAt: 0,
+				finishedAt: e.timestamp,
+				duration: 0,
+				events: [],
+				features: [],
+				diagnostics: [],
+				cancelled: !1,
+				interrupted: !1,
+				completed: !0,
+				page: r
+			}, this.insertRecord(i), this.activeVisitId = t;
+			for (let e of this.records.values()) e.type === "deferred" && e.parentVisitId === void 0 && (e.parentVisitId = t, e.previousPage = r);
+		}
+		return i ? (i.events.push(e), r && (i.page = r, i.features = t(i, r)), i.finishedAt || (i.finishedAt = e.timestamp, i.duration = e.timestamp - i.startedAt, i.completed = !0), i.diagnostics = g(i), i) : null;
+	}
+	handleBeforeUpdate(e, n) {
+		let r = this.resolveByActiveId();
+		if (!r) return null;
+		r.events.push(e);
+		let i = n.page;
+		if (i) {
+			if (this.lastPage) for (let e of this.records.values()) e.type === "deferred" && !e.page && (e.previousPage = this.lastPage);
+			this.lastPage = i, r.page || (r.page = i, r.features = t(r, i));
+		}
+		return r;
+	}
+	handleGenericEvent(e, t) {
+		let n = this.resolveByFingerprint(e) ?? this.resolveByActiveId();
+		if (!n) return null;
+		if (n.events.push(e), e.name === "inertia:error") n.error = t.errors;
+		else if (e.name === "inertia:httpException") {
+			let e = t.response;
+			if (e && (n.status = e.status, n.status === 409)) {
+				n.type = "redirect";
+				let t = e.headers;
+				t && (n.redirectUrl = t["x-inertia-location"] ?? t["x-inertia-redirect"]);
+			}
+		} else e.name === "inertia:networkError" && (n.error = t.error);
+		return n.diagnostics = g(n), n;
+	}
+	createPrefetchRecord(e, t, n, r) {
+		let i = this.nextVisitId++, a = {
+			visitId: i,
+			type: "prefetch",
+			method: (e.method ?? "GET").toUpperCase(),
+			url: this.extractUrl(e),
+			only: e.only?.length ? e.only : void 0,
+			except: e.except?.length ? e.except : void 0,
+			startedAt: r,
+			events: [t, n],
+			features: [{
+				type: "prefetch",
+				label: "PREFETCH"
+			}],
+			diagnostics: [],
+			cancelled: !1,
+			interrupted: !1,
+			completed: !1
+		};
+		return this.insertRecord(a), this.pushFingerprint(this.visitFingerprint(e), i), this.activeVisitId = i, a;
+	}
+	visitFingerprint(e) {
+		return e ? `${this.extractUrl(e)}|${(e.method ?? "GET").toUpperCase()}|${JSON.stringify(e.only ?? [])}|${JSON.stringify(e.except ?? [])}|${e.deferredProps ? "d" : ""}|${e.prefetch ? "p" : ""}` : "(no-visit)";
+	}
+	pushFingerprint(e, t) {
+		let n = this.fingerprintMap.get(e);
+		n ? n.push(t) : this.fingerprintMap.set(e, [t]);
+	}
+	removeFromFingerprintMap(e) {
+		for (let [t, n] of this.fingerprintMap) {
+			let r = n.indexOf(e);
+			if (r !== -1) {
+				n.splice(r, 1), n.length === 0 && this.fingerprintMap.delete(t);
+				return;
+			}
+		}
+	}
+	resolveByFingerprint(e) {
+		let t = this.extractVisit(e.detail);
+		if (!t) return null;
+		let n = this.visitFingerprint(t), r = this.fingerprintMap.get(n);
+		if (!r || r.length === 0) return null;
+		if (e.name === "inertia:finish") {
+			let e = r.shift();
+			return r.length === 0 && this.fingerprintMap.delete(n), this.records.get(e) ?? null;
+		}
+		return this.records.get(r[0]) ?? null;
+	}
+	resolveByActiveId() {
+		return this.activeVisitId === null ? null : this.records.get(this.activeVisitId) ?? null;
+	}
+	insertRecord(e) {
+		this.records.set(e.visitId, e);
+		let t = this.sortedRecords.length - 1;
+		for (; t >= 0 && (this.sortedRecords[t].startedAt > e.startedAt || this.sortedRecords[t].startedAt === e.startedAt && this.sortedRecords[t].visitId > e.visitId);) t--;
+		this.sortedRecords.splice(t + 1, 0, e), this.sortedRecords.length > this.maxRecords && this.evictOldest();
+	}
+	evictOldest() {
+		let e = this.sortedRecords.findIndex((e) => e.finishedAt != null), [t] = this.sortedRecords.splice(e === -1 ? 0 : e, 1);
+		t && (this.records.delete(t.visitId), this.removeFromFingerprintMap(t.visitId), this.removeFromInertiaVisitIdMap(t), this._evictedCount++);
+	}
+	removeFromInertiaVisitIdMap(e) {
+		e.inertiaVisitId && this.recordByInertiaVisitId.delete(e.inertiaVisitId);
+	}
+	extractVisit(e) {
+		let t = e.visit;
+		if (typeof t == "object" && t) return t;
+	}
+	extractVisitOptions(e) {
+		let t = /* @__PURE__ */ new Set([
+			"method",
+			"url",
+			"href",
+			"cancelToken",
+			"signal",
+			"only",
+			"except",
+			"deferredProps",
+			"completed",
+			"cancelled",
+			"interrupted",
+			"prefetch"
+		]), n = {};
+		for (let [r, i] of Object.entries(e)) t.has(r) || i !== !1 && i != null && (Array.isArray(i) && i.length === 0 || (typeof i != "object" || !i || Array.isArray(i) || Object.keys(i).length !== 0) && (n[r] = i));
+		return Object.keys(n).length > 0 ? n : void 0;
+	}
+	classifyVisitType(e) {
+		if (!e) return "full";
+		let t = e.only, n = e.except;
+		return t && t.length > 0 || n && n.length > 0 ? "partial" : e.prefetch ? "prefetch" : "full";
+	}
+	extractUrl(e) {
+		if (!e) return "(unknown)";
+		let t = e.url;
+		return t instanceof URL ? t.pathname + t.search : typeof t == "string" ? t : "(unknown)";
+	}
+	isDeferredReload(e) {
+		return e.deferredProps === !0;
+	}
+	findNestingParentVisitId(e) {
+		return this.sortedRecords.findLast((t) => (e === void 0 || t.url === e) && t.type !== "deferred" && t.type !== "prefetch")?.visitId;
+	}
+}, b = o("inertia-devtools-session");
+function x(e) {
+	return {
+		visitId: e.visitId,
+		type: e.type,
+		method: e.method,
+		url: e.url,
+		status: e.status
+	};
+}
+function S(e) {
+	b.save({
+		savedAt: Date.now(),
+		requests: e.map(x)
+	});
+}
+function C() {
+	return b.load();
+}
+function w() {
+	b.clear();
+}
+//#endregion
+//#region src/inertia/core/store.ts
+var T = class {
+	correlator;
+	subscribers = /* @__PURE__ */ new Set();
+	nextEventId = 1;
+	tick = 0;
+	_paused = !1;
+	previousSession = null;
+	saveTimer;
+	constructor() {
+		this.correlator = new y(), this.previousSession = C();
+	}
+	get requests() {
+		return this.correlator.getRequests().slice();
+	}
+	get currentPage() {
+		return this.correlator.getCurrentPage();
+	}
+	getRequest(e) {
+		return this.correlator.getRequest(e);
+	}
+	isInertiaRequestUrl(e) {
+		return this.correlator.hasRequestWithUrl(e);
+	}
+	get evictedCount() {
+		return this.correlator.evictedCount;
+	}
+	get paused() {
+		return this._paused;
+	}
+	get previousSessionRequests() {
+		return this.previousSession?.requests ?? [];
+	}
+	getState() {
+		return {
+			requests: this.requests,
+			currentPage: this.currentPage,
+			evictedCount: this.evictedCount,
+			paused: this._paused,
+			tick: this.tick
+		};
+	}
+	captureEvent(e, t) {
+		if (this._paused || !(t instanceof CustomEvent)) return;
+		let n = r(t.detail), i = {
+			id: this.nextEventId++,
+			name: e,
+			timestamp: performance.now(),
+			detail: n
+		};
+		this.correlator.processEvent(i), this.notify();
+	}
+	captureNetworkTiming(e) {
+		this._paused || (this.correlator.linkNetworkTiming(e), this.notify());
+	}
+	captureInterceptedRequest(e, t) {
+		this._paused || (this.correlator.attachRequestHeaders(e, t), this.notify());
+	}
+	captureInterceptedResponse(e, t) {
+		this._paused || (this.correlator.attachResponseData(e, t), this.notify());
+	}
+	captureClientVisit(e, t, n) {
+		this._paused || (this.correlator.processClientVisit(e, t, n), this.notify());
+	}
+	subscribe(e) {
+		return this.subscribers.add(e), () => {
+			this.subscribers.delete(e);
+		};
+	}
+	setPaused(e) {
+		this._paused = e, this.notify();
+	}
+	clear() {
+		this.correlator.clear(), this.nextEventId = 1, w(), this.previousSession = null, this.notify();
+	}
+	notify() {
+		this.tick++;
+		let e = this.getState();
+		for (let t of this.subscribers) try {
+			t(e);
+		} catch (e) {
+			console.warn("[storefront-devtools] Subscriber error:", e);
+		}
+		clearTimeout(this.saveTimer), this.saveTimer = setTimeout(() => S(this.requests), 1e3);
+	}
+}, E = [
+	"inertia:before",
+	"inertia:start",
+	"inertia:progress",
+	"inertia:success",
+	"inertia:error",
+	"inertia:httpException",
+	"inertia:networkError",
+	"inertia:finish",
+	"inertia:cancel",
+	"inertia:beforeUpdate",
+	"inertia:navigate",
+	"inertia:flash",
+	"inertia:prefetching",
+	"inertia:prefetched"
+];
+//#endregion
+//#region src/inertia/core/capture.ts
+function D(e) {
+	let t = [];
+	for (let n of E) {
+		let r = (t) => {
+			try {
+				e.captureEvent(n, t);
+			} catch (e) {
+				console.error("[storefront-devtools] Error capturing event", e);
+			}
+		};
+		document.addEventListener(n, r), t.push(() => document.removeEventListener(n, r));
+	}
+	return () => {
+		t.forEach((e) => e());
+	};
+}
+//#endregion
+//#region src/inertia/core/history-capture.ts
+function O(e) {
+	if (typeof e != "object" || !e) return null;
+	let t = e;
+	if (!("page" in t)) return null;
+	if (t.page instanceof ArrayBuffer) return "encrypted";
+	if (typeof t.page != "object" || t.page == null) return null;
+	let n = t.page;
+	return typeof n.component != "string" || typeof n.props != "object" ? null : t.page;
+}
+function k(e, t) {
+	return e.url !== t.url || e.component !== t.component || !n(e.props, t.props) || !n(e.flash, t.flash);
+}
+function A(e) {
+	if (typeof window > "u") return () => {};
+	let t = history.pushState.bind(history), n = history.replaceState.bind(history), r = 0, i = (e) => {
+		e.detail?.visit?.prefetch || r++;
+	}, a = (e) => {
+		let t = e.detail?.visit;
+		t && (t.cancelled || t.interrupted) && r > 0 && r--;
+	};
+	document.addEventListener("inertia:before", i), document.addEventListener("inertia:finish", a);
+	function o(t, n, r) {
+		try {
+			e.captureClientVisit(t === "pushState" ? "push" : "replace", n, r);
+		} catch (e) {
+			console.error("[storefront-devtools] Error in history capture", e);
+		}
+	}
+	function s(t, n) {
+		setTimeout(() => {
+			let r = e.currentPage;
+			r && k(n, r) && o(t, r, n);
+		}, 0);
+	}
+	function c(t, n) {
+		let i = O(n);
+		if (!i) return;
+		let a = e.currentPage;
+		if (a) {
+			if (i === "encrypted") {
+				if (r > 0) {
+					r--;
+					return;
+				}
+				s(t, a);
+			} else {
+				if (r > 0) {
+					r--;
+					return;
+				}
+				if (!k(a, i)) return;
+				o(t, i, a);
+			}
+		}
+	}
+	return history.pushState = function(e, n, r) {
+		t(e, n, r), c("pushState", e);
+	}, history.replaceState = function(e, t, r) {
+		n(e, t, r), c("replaceState", e);
+	}, () => {
+		history.pushState = t, history.replaceState = n, document.removeEventListener("inertia:before", i), document.removeEventListener("inertia:finish", a);
+	};
+}
+//#endregion
+//#region src/inertia/core/network.ts
+function j(e, t) {
+	if (typeof PerformanceObserver > "u") return () => {};
+	let n = new PerformanceObserver((n) => {
+		for (let r of n.getEntries()) {
+			let n = r;
+			if ((n.initiatorType === "xmlhttprequest" || n.initiatorType === "fetch") && e(n.name)) try {
+				t({
+					url: n.name,
+					duration: n.duration,
+					startedAt: n.startTime,
+					finishedAt: n.startTime + n.duration,
+					transferSize: n.transferSize
+				});
+			} catch (e) {
+				console.error("[storefront-devtools] Error processing network timing", e);
+			}
+		}
+	});
+	return n.observe({
+		type: "resource",
+		buffered: !1
+	}), () => n.disconnect();
+}
+//#endregion
+//#region src/inertia/core/interceptors.ts
+function M(e) {
+	if (!e) return {};
+	let t = {};
+	for (let [n, r] of Object.entries(e)) t[n.toLowerCase()] = String(r);
+	return t;
+}
+function N(e) {
+	let t = typeof e == "string" ? (() => {
+		try {
+			return JSON.parse(e);
+		} catch {
+			return;
+		}
+	})() : e;
+	if (typeof t == "object" && t && "props" in t && typeof t.props == "object" && t.props !== null) return t.props;
+}
+var P = 100, F = 1e4;
+function I(e, t) {
+	let n = e.onVisitRequest((e, n) => {
+		try {
+			let r = M(n.headers);
+			t.captureInterceptedRequest(e.id, s(r));
+		} catch (e) {
+			console.error("[storefront-devtools] Error capturing intercepted request", e);
+		}
+		return n;
+	}), r = e.onVisitResponse((e, n) => {
+		try {
+			let r = M(n.headers), o = N(n.data);
+			t.captureInterceptedResponse(e.id, {
+				headers: s(r),
+				props: o ? i(o, { redactKey: a }) : void 0
+			});
+		} catch (e) {
+			console.error("[storefront-devtools] Error capturing intercepted response", e);
+		}
+		return n;
+	});
+	return () => {
+		n(), r();
+	};
+}
+function L(e) {
+	if (typeof window > "u") return () => {};
+	if (window.__inertia_interceptors__) return I(window.__inertia_interceptors__, e);
+	let t, n = Date.now(), r = setInterval(() => {
+		if (window.__inertia_interceptors__) {
+			clearInterval(r), t = I(window.__inertia_interceptors__, e);
+			return;
+		}
+		Date.now() - n > F && clearInterval(r);
+	}, P);
+	return () => {
+		clearInterval(r), t?.();
+	};
+}
+//#endregion
+//#region src/inertia/client/index.ts
+if (typeof window < "u" && typeof document < "u" && !window.__STOREFRONT_DEVTOOLS_STORE__) {
+	let e = new T();
+	window.__STOREFRONT_DEVTOOLS_STORE__ = e, D(e), A(e), j((t) => e.isInertiaRequestUrl(t), (t) => e.captureNetworkTiming(t)), L(e);
+}
+//#endregion

package/dist/inertia/core/capture.d.ts

@@ -0,0 +1,15 @@
+import { DevToolsStore } from './store';
+import { StopFunction } from './types';
+/**
+ * Subscribes to all Inertia DOM events and feeds them into the store.
+ * Every handler is wrapped in try/catch so the devtools can never crash the
+ * host app.
+ *
+ * Prefetch requests fire the standard lifecycle (before, start, finish) too,
+ * with `visit.prefetch = true`; the correlator classifies them from that flag.
+ *
+ * @param store - The devtools store that receives each captured event.
+ * @returns A function that unsubscribes all listeners.
+ */
+export declare function startCapture(store: DevToolsStore): StopFunction;
+//# sourceMappingURL=capture.d.ts.map

package/dist/inertia/core/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../src/inertia/core/capture.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAkB/D"}