@tanstack/start-client-core 1.169.4 → 1.170.0

package/dist/esm/hydration/runtime.js

@@ -0,0 +1,129 @@
+import { hydrateIdAttribute, hydrateWhenAttribute } from "./constants.js";
+//#region src/hydration/runtime.ts
+var hydrateIdSelector = `[${hydrateIdAttribute}]`;
+var gateRegistry = /* @__PURE__ */ new Map();
+var resolvedGateIds = /* @__PURE__ */ new Set();
+var fallbackHtmlByGateId = /* @__PURE__ */ new Map();
+function createResolvedGate(id, when) {
+	return {
+		id,
+		when,
+		promise: Promise.resolve(),
+		resolve: () => {},
+		resolved: true,
+		consumers: 0,
+		resolveListeners: /* @__PURE__ */ new Set()
+	};
+}
+function getOrCreateGate(id, when) {
+	const existing = gateRegistry.get(id);
+	if (existing?.when === when) {
+		existing.consumers++;
+		return existing;
+	}
+	let resolvePromise;
+	const gate = {
+		id,
+		promise: new Promise((resolve) => {
+			resolvePromise = resolve;
+		}),
+		resolved: false,
+		consumers: 1,
+		when,
+		resolveListeners: /* @__PURE__ */ new Set(),
+		resolve: () => {
+			if (gate.resolved) return;
+			gate.resolved = true;
+			resolvePromise();
+			gate.resolveListeners.forEach((listener) => listener());
+			gate.resolveListeners.clear();
+		}
+	};
+	gateRegistry.set(id, gate);
+	if (when !== "never" && resolvedGateIds.has(id)) {
+		resolvedGateIds.delete(id);
+		gate.resolve();
+	}
+	return gate;
+}
+function releaseGate(gate) {
+	resolvedGateIds.delete(gate.id);
+	gate.consumers--;
+	if (gate.consumers > 0) return;
+	if (gateRegistry.get(gate.id) === gate) {
+		gateRegistry.delete(gate.id);
+		fallbackHtmlByGateId.delete(gate.id);
+		gate.resolveListeners.clear();
+	}
+}
+function onGateResolve(gate, listener) {
+	if (gate.resolved) {
+		listener();
+		return () => {};
+	}
+	gate.resolveListeners.add(listener);
+	return () => {
+		gate.resolveListeners.delete(listener);
+	};
+}
+function runHydrationStrategyCleanup(cleanup) {
+	if (typeof cleanup === "function") return cleanup;
+}
+function waitForHydrationPrefetchStrategy(strategy, options) {
+	if (options.signal.aborted) return Promise.resolve("abort");
+	return new Promise((resolve) => {
+		const state = { disposed: false };
+		const cleanupStrategyRef = { current: void 0 };
+		let cleanupHydrate = () => {};
+		const finish = (reason) => {
+			if (state.disposed) return;
+			state.disposed = true;
+			options.signal.removeEventListener("abort", onAbort);
+			cleanupHydrate();
+			runHydrationStrategyCleanup(cleanupStrategyRef.current)?.();
+			resolve(reason);
+		};
+		const onAbort = () => finish("abort");
+		options.signal.addEventListener("abort", onAbort, { once: true });
+		cleanupHydrate = options.onHydrate(() => finish("hydrate"));
+		const cleanupStrategy = strategy._s?.({
+			element: options.element,
+			prefetch: () => finish("prefetch")
+		});
+		cleanupStrategyRef.current = cleanupStrategy;
+		if (state.disposed) runHydrationStrategyCleanup(cleanupStrategy)?.();
+	});
+}
+function getMarkerGate(marker) {
+	const id = marker.getAttribute(hydrateIdAttribute);
+	return id ? gateRegistry.get(id) : void 0;
+}
+function resolveHydrationMarker(marker) {
+	const id = marker.getAttribute(hydrateIdAttribute);
+	const when = marker.getAttribute(hydrateWhenAttribute);
+	if (!id || !when || when === "never") return;
+	const gate = gateRegistry.get(id);
+	if (gate) {
+		if (gate.when !== "never") gate.resolve();
+		return;
+	}
+	resolvedGateIds.add(id);
+}
+function clearResolvedGateIdsInMarker(marker) {
+	const ownId = marker.getAttribute(hydrateIdAttribute);
+	if (ownId) resolvedGateIds.delete(ownId);
+	marker.querySelectorAll(hydrateIdSelector).forEach((childMarker) => {
+		const childId = childMarker.getAttribute(hydrateIdAttribute);
+		if (childId) resolvedGateIds.delete(childId);
+	});
+}
+function saveFallbackHtml(id, element) {
+	if (!fallbackHtmlByGateId.has(id)) fallbackHtmlByGateId.set(id, element.innerHTML);
+}
+function getFallbackHtml(id) {
+	return fallbackHtmlByGateId.get(id);
+}
+//#endregion
+export { clearResolvedGateIdsInMarker, createResolvedGate, getFallbackHtml, getMarkerGate, getOrCreateGate, onGateResolve, releaseGate, resolveHydrationMarker, runHydrationStrategyCleanup, saveFallbackHtml, waitForHydrationPrefetchStrategy };
+
+//# sourceMappingURL=runtime.js.map

package/dist/esm/hydration/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":[],"sources":["../../../src/hydration/runtime.ts"],"sourcesContent":["import { hydrateIdAttribute, hydrateWhenAttribute } from './constants'\nimport type {\n  HydrationPrefetchStrategy,\n  HydrationPrefetchWaitReason,\n  HydrationRuntimeGate,\n  HydrationWhen,\n} from './types'\n\nconst hydrateIdSelector = `[${hydrateIdAttribute}]`\n\nexport type HydrationGateRecord = HydrationRuntimeGate & {\n  id: string\n  when: HydrationWhen\n  promise: Promise<void>\n  consumers: number\n  resolveListeners: Set<() => void>\n}\n\nconst gateRegistry = /* @__PURE__ */ new Map<string, HydrationGateRecord>()\nconst resolvedGateIds = /* @__PURE__ */ new Set<string>()\nconst fallbackHtmlByGateId = /* @__PURE__ */ new Map<string, string>()\n\nexport function createResolvedGate(\n  id: string,\n  when: HydrationWhen,\n): HydrationGateRecord {\n  return {\n    id,\n    when,\n    promise: Promise.resolve(),\n    resolve: () => {},\n    resolved: true,\n    consumers: 0,\n    resolveListeners: new Set<() => void>(),\n  }\n}\n\nexport function getOrCreateGate(\n  id: string,\n  when: HydrationWhen,\n): HydrationGateRecord {\n  const existing = gateRegistry.get(id)\n  if (existing?.when === when) {\n    existing.consumers++\n    return existing\n  }\n\n  let resolvePromise!: () => void\n  const promise = new Promise<void>((resolve) => {\n    resolvePromise = resolve\n  })\n\n  const gate: HydrationGateRecord = {\n    id,\n    promise,\n    resolved: false,\n    consumers: 1,\n    when,\n    resolveListeners: new Set(),\n    resolve: () => {\n      if (gate.resolved) return\n      gate.resolved = true\n      resolvePromise()\n      gate.resolveListeners.forEach((listener) => listener())\n      gate.resolveListeners.clear()\n    },\n  }\n\n  gateRegistry.set(id, gate)\n  if (when !== 'never' && resolvedGateIds.has(id)) {\n    resolvedGateIds.delete(id)\n    gate.resolve()\n  }\n  return gate\n}\n\nexport function releaseGate(gate: HydrationGateRecord) {\n  resolvedGateIds.delete(gate.id)\n  gate.consumers--\n  if (gate.consumers > 0) return\n  if (gateRegistry.get(gate.id) === gate) {\n    gateRegistry.delete(gate.id)\n    fallbackHtmlByGateId.delete(gate.id)\n    gate.resolveListeners.clear()\n  }\n}\n\nexport function onGateResolve(gate: HydrationGateRecord, listener: () => void) {\n  if (gate.resolved) {\n    listener()\n    return () => {}\n  }\n\n  gate.resolveListeners.add(listener)\n  return () => {\n    gate.resolveListeners.delete(listener)\n  }\n}\n\nexport function runHydrationStrategyCleanup(cleanup: void | (() => void)) {\n  if (typeof cleanup === 'function') return cleanup\n  return undefined\n}\n\nexport function waitForHydrationPrefetchStrategy(\n  strategy: HydrationPrefetchStrategy,\n  options: {\n    element: Element | null\n    signal: AbortSignal\n    onHydrate: (listener: () => void) => () => void\n  },\n): Promise<HydrationPrefetchWaitReason> {\n  if (options.signal.aborted) {\n    return Promise.resolve('abort')\n  }\n\n  return new Promise((resolve) => {\n    const state = { disposed: false }\n    const cleanupStrategyRef: { current: void | (() => void) } = {\n      current: undefined,\n    }\n    let cleanupHydrate = () => {}\n\n    const finish = (reason: HydrationPrefetchWaitReason) => {\n      if (state.disposed) return\n      state.disposed = true\n      options.signal.removeEventListener('abort', onAbort)\n      cleanupHydrate()\n      runHydrationStrategyCleanup(cleanupStrategyRef.current)?.()\n      resolve(reason)\n    }\n\n    const onAbort = () => finish('abort')\n\n    options.signal.addEventListener('abort', onAbort, { once: true })\n    cleanupHydrate = options.onHydrate(() => finish('hydrate'))\n    const cleanupStrategy = strategy._s?.({\n      element: options.element,\n      prefetch: () => finish('prefetch'),\n    })\n    cleanupStrategyRef.current = cleanupStrategy\n    if (state.disposed) {\n      runHydrationStrategyCleanup(cleanupStrategy)?.()\n    }\n  })\n}\n\nexport function getMarkerGate(marker: Element) {\n  const id = marker.getAttribute(hydrateIdAttribute)\n  return id ? gateRegistry.get(id) : undefined\n}\n\nexport function resolveHydrationMarker(marker: Element) {\n  const id = marker.getAttribute(hydrateIdAttribute)\n  const when = marker.getAttribute(hydrateWhenAttribute)\n  if (!id || !when || when === 'never') {\n    return\n  }\n\n  const gate = gateRegistry.get(id)\n  if (gate) {\n    if (gate.when !== 'never') gate.resolve()\n    return\n  }\n\n  resolvedGateIds.add(id)\n}\n\nexport function clearResolvedGateIdsInMarker(marker: Element) {\n  const ownId = marker.getAttribute(hydrateIdAttribute)\n  if (ownId) {\n    resolvedGateIds.delete(ownId)\n  }\n\n  marker.querySelectorAll(hydrateIdSelector).forEach((childMarker) => {\n    const childId = childMarker.getAttribute(hydrateIdAttribute)\n    if (childId) {\n      resolvedGateIds.delete(childId)\n    }\n  })\n}\n\nexport function saveFallbackHtml(id: string, element: Element) {\n  if (!fallbackHtmlByGateId.has(id)) {\n    fallbackHtmlByGateId.set(id, element.innerHTML)\n  }\n}\n\nexport function getFallbackHtml(id: string) {\n  return fallbackHtmlByGateId.get(id)\n}\n"],"mappings":"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"}

package/dist/esm/hydration/types.d.ts

@@ -0,0 +1,38 @@
+export type HydrationWhen = 'load' | 'idle' | 'visible' | 'media' | 'interaction' | 'condition' | 'never' | 'dynamic';
+export type HydrationInteractionEvent = 'auxclick' | 'click' | 'contextmenu' | 'dblclick' | 'focusin' | 'keydown' | 'keyup' | 'mousedown' | 'mouseenter' | 'mouseover' | 'mouseup' | 'pointerdown' | 'pointerenter' | 'pointerover' | 'pointerup';
+export type HydrationInteractionEvents = HydrationInteractionEvent | ReadonlyArray<HydrationInteractionEvent>;
+export type HydrationMarkerAttributes = Record<string, string | undefined>;
+export type HydrationRuntimeGate = {
+    id?: string;
+    when?: HydrationWhen;
+    resolved: boolean;
+    resolve: () => void;
+};
+export type HydrationRuntimeContext = {
+    element: Element | null;
+    gate?: HydrationRuntimeGate;
+    prefetch?: () => void;
+    delegated?: boolean;
+};
+export type HydrationStrategyTypes<TWhen extends HydrationWhen = HydrationWhen, TCanPrefetch extends boolean = boolean> = {
+    when: TWhen;
+    canPrefetch: TCanPrefetch;
+};
+export type HydrationStrategy<TWhen extends HydrationWhen = HydrationWhen, TCanPrefetch extends boolean = boolean> = {
+    _t?: TWhen;
+    readonly '~types'?: HydrationStrategyTypes<TWhen, TCanPrefetch>;
+    _d?: () => boolean;
+    _s?: (context: HydrationRuntimeContext) => void | (() => void);
+    _o?: (id: string) => void;
+    _a?: () => HydrationMarkerAttributes | undefined;
+};
+export type HydrationPrefetchWhen = Exclude<HydrationWhen, 'condition' | 'never' | 'dynamic'>;
+export type HydrationPrefetchStrategy<TWhen extends HydrationPrefetchWhen = HydrationPrefetchWhen> = HydrationStrategy<TWhen, true>;
+export type HydrationPrefetchWaitReason = 'prefetch' | 'hydrate' | 'abort';
+export type HydrationPrefetchContext = {
+    element: Element | null;
+    signal: AbortSignal;
+    preload: () => Promise<void>;
+    waitFor: (strategy: HydrationPrefetchStrategy) => Promise<HydrationPrefetchWaitReason>;
+};
+export type HydrationPrefetchFunction = (context: HydrationPrefetchContext) => void | Promise<void>;

package/dist/esm/hydration/visible.d.ts

@@ -0,0 +1,8 @@
+import { HydrationPrefetchStrategy } from './types.js';
+declare const visibleType = "visible";
+export type VisibleHydrationOptions = {
+    rootMargin?: string;
+    threshold?: number | Array<number>;
+};
+export declare function visible(options?: VisibleHydrationOptions): HydrationPrefetchStrategy<typeof visibleType>;
+export {};

package/dist/esm/hydration/visible.js

@@ -0,0 +1,67 @@
+//#region src/hydration/visible.ts
+var visibleType = "visible";
+var observerRegistry = /* @__PURE__ */ new Map();
+function cleanupVisibleObserverEntry(observerEntry) {
+	if (observerEntry.elements.size > 0) return;
+	observerEntry.observer.disconnect();
+	observerRegistry.delete(observerEntry.key);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function visible(options = {}) {
+	const rootMargin = options.rootMargin ?? "600px";
+	const threshold = options.threshold ?? 0;
+	return {
+		_t: visibleType,
+		_s: ({ element, gate, prefetch }) => {
+			const callback = prefetch ?? gate.resolve;
+			if (!element) {
+				callback();
+				return;
+			}
+			const key = `${rootMargin}|${Array.isArray(threshold) ? threshold.join(",") : String(threshold)}`;
+			let observerEntry = observerRegistry.get(key);
+			if (!observerEntry) {
+				const entry = {
+					key,
+					elements: /* @__PURE__ */ new Map(),
+					observer: new IntersectionObserver((entries) => {
+						for (const intersectingEntry of entries) {
+							if (!intersectingEntry.isIntersecting) continue;
+							const callbacks = entry.elements.get(intersectingEntry.target);
+							if (!callbacks) continue;
+							callbacks.forEach((callback) => callback());
+							entry.elements.delete(intersectingEntry.target);
+							entry.observer.unobserve(intersectingEntry.target);
+							cleanupVisibleObserverEntry(entry);
+						}
+					}, {
+						rootMargin,
+						threshold
+					})
+				};
+				observerRegistry.set(key, entry);
+				observerEntry = entry;
+			}
+			let callbacks = observerEntry.elements.get(element);
+			if (!callbacks) {
+				callbacks = /* @__PURE__ */ new Set();
+				observerEntry.elements.set(element, callbacks);
+				observerEntry.observer.observe(element);
+			}
+			callbacks.add(callback);
+			return () => {
+				const currentCallbacks = observerEntry.elements.get(element);
+				currentCallbacks?.delete(callback);
+				if (currentCallbacks?.size === 0) {
+					observerEntry.elements.delete(element);
+					observerEntry.observer.unobserve(element);
+				}
+				cleanupVisibleObserverEntry(observerEntry);
+			};
+		}
+	};
+}
+//#endregion
+export { visible };
+
+//# sourceMappingURL=visible.js.map

package/dist/esm/hydration/visible.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visible.js","names":[],"sources":["../../../src/hydration/visible.ts"],"sourcesContent":["import type { HydrationPrefetchStrategy } from './types'\n\nconst visibleType = 'visible'\n\nexport type VisibleHydrationOptions = {\n  rootMargin?: string\n  threshold?: number | Array<number>\n}\n\ntype VisibleObserverEntry = {\n  key: string\n  observer: IntersectionObserver\n  elements: Map<Element, Set<() => void>>\n}\n\nconst observerRegistry = /* @__PURE__ */ new Map<string, VisibleObserverEntry>()\n\nfunction cleanupVisibleObserverEntry(observerEntry: VisibleObserverEntry) {\n  if (observerEntry.elements.size > 0) return\n  observerEntry.observer.disconnect()\n  observerRegistry.delete(observerEntry.key)\n}\n\n/* @__NO_SIDE_EFFECTS__ */\nexport function visible(\n  options: VisibleHydrationOptions = {},\n): HydrationPrefetchStrategy<typeof visibleType> {\n  const rootMargin = options.rootMargin ?? '600px'\n  const threshold = options.threshold ?? 0\n\n  return {\n    _t: visibleType,\n    _s: ({ element, gate, prefetch }) => {\n      const callback = prefetch ?? gate!.resolve\n\n      if (!element) {\n        callback()\n        return\n      }\n\n      const key = `${rootMargin}|${\n        Array.isArray(threshold) ? threshold.join(',') : String(threshold)\n      }`\n      let observerEntry = observerRegistry.get(key)\n\n      if (!observerEntry) {\n        const entry: VisibleObserverEntry = {\n          key,\n          elements: new Map<Element, Set<() => void>>(),\n          observer: new IntersectionObserver(\n            (entries) => {\n              for (const intersectingEntry of entries) {\n                if (!intersectingEntry.isIntersecting) continue\n\n                const callbacks = entry.elements.get(intersectingEntry.target)\n                if (!callbacks) continue\n\n                callbacks.forEach((callback) => callback())\n                entry.elements.delete(intersectingEntry.target)\n                entry.observer.unobserve(intersectingEntry.target)\n                cleanupVisibleObserverEntry(entry)\n              }\n            },\n            { rootMargin, threshold },\n          ),\n        }\n        observerRegistry.set(key, entry)\n        observerEntry = entry\n      }\n\n      let callbacks = observerEntry.elements.get(element)\n      if (!callbacks) {\n        callbacks = new Set()\n        observerEntry.elements.set(element, callbacks)\n        observerEntry.observer.observe(element)\n      }\n      callbacks.add(callback)\n\n      return () => {\n        const currentCallbacks = observerEntry.elements.get(element)\n        currentCallbacks?.delete(callback)\n        if (currentCallbacks?.size === 0) {\n          observerEntry.elements.delete(element)\n          observerEntry.observer.unobserve(element)\n        }\n        cleanupVisibleObserverEntry(observerEntry)\n      }\n    },\n  }\n}\n"],"mappings":";AAEA,IAAM,cAAc;AAapB,IAAM,mCAAmC,IAAI,KAAmC;AAEhF,SAAS,4BAA4B,eAAqC;AACxE,KAAI,cAAc,SAAS,OAAO,EAAG;AACrC,eAAc,SAAS,YAAY;AACnC,kBAAiB,OAAO,cAAc,IAAI;;;AAI5C,SAAgB,QACd,UAAmC,EAAE,EACU;CAC/C,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,YAAY,QAAQ,aAAa;AAEvC,QAAO;EACL,IAAI;EACJ,KAAK,EAAE,SAAS,MAAM,eAAe;GACnC,MAAM,WAAW,YAAY,KAAM;AAEnC,OAAI,CAAC,SAAS;AACZ,cAAU;AACV;;GAGF,MAAM,MAAM,GAAG,WAAW,GACxB,MAAM,QAAQ,UAAU,GAAG,UAAU,KAAK,IAAI,GAAG,OAAO,UAAU;GAEpE,IAAI,gBAAgB,iBAAiB,IAAI,IAAI;AAE7C,OAAI,CAAC,eAAe;IAClB,MAAM,QAA8B;KAClC;KACA,0BAAU,IAAI,KAA+B;KAC7C,UAAU,IAAI,sBACX,YAAY;AACX,WAAK,MAAM,qBAAqB,SAAS;AACvC,WAAI,CAAC,kBAAkB,eAAgB;OAEvC,MAAM,YAAY,MAAM,SAAS,IAAI,kBAAkB,OAAO;AAC9D,WAAI,CAAC,UAAW;AAEhB,iBAAU,SAAS,aAAa,UAAU,CAAC;AAC3C,aAAM,SAAS,OAAO,kBAAkB,OAAO;AAC/C,aAAM,SAAS,UAAU,kBAAkB,OAAO;AAClD,mCAA4B,MAAM;;QAGtC;MAAE;MAAY;MAAW,CAC1B;KACF;AACD,qBAAiB,IAAI,KAAK,MAAM;AAChC,oBAAgB;;GAGlB,IAAI,YAAY,cAAc,SAAS,IAAI,QAAQ;AACnD,OAAI,CAAC,WAAW;AACd,gCAAY,IAAI,KAAK;AACrB,kBAAc,SAAS,IAAI,SAAS,UAAU;AAC9C,kBAAc,SAAS,QAAQ,QAAQ;;AAEzC,aAAU,IAAI,SAAS;AAEvB,gBAAa;IACX,MAAM,mBAAmB,cAAc,SAAS,IAAI,QAAQ;AAC5D,sBAAkB,OAAO,SAAS;AAClC,QAAI,kBAAkB,SAAS,GAAG;AAChC,mBAAc,SAAS,OAAO,QAAQ;AACtC,mBAAc,SAAS,UAAU,QAAQ;;AAE3C,gCAA4B,cAAc;;;EAG/C"}

package/dist/esm/hydration.d.ts

@@ -0,0 +1,18 @@
+export { condition } from './hydration/condition.js';
+export type { HydrationCondition } from './hydration/condition.js';
+export { hydrateIdAttribute, hydrateInteractionEventsAttribute, hydrateWhenAttribute, } from './hydration/constants.js';
+export declare const hydrateIdSelector = "[data-ts-hydrate-id]";
+export { idle } from './hydration/idle.js';
+export type { IdleHydrationOptions } from './hydration/idle.js';
+export { interaction } from './hydration/interaction.js';
+export { load } from './hydration/load.js';
+export { media } from './hydration/media.js';
+export { never } from './hydration/never.js';
+export { clearResolvedGateIdsInMarker, createResolvedGate, getFallbackHtml, getMarkerGate, getOrCreateGate, onGateResolve, releaseGate, resolveHydrationMarker, runHydrationStrategyCleanup, saveFallbackHtml, waitForHydrationPrefetchStrategy, } from './hydration/runtime.js';
+export { withHydrationRenderer } from './hydration/renderer.js';
+export { visible } from './hydration/visible.js';
+export { listenForDelegatedHydrationIntent } from './hydration/interaction.js';
+export type { VisibleHydrationOptions } from './hydration/visible.js';
+export type { HydrationGateRecord } from './hydration/runtime.js';
+export type { HydrationStrategyWithRenderer } from './hydration/renderer.js';
+export type { HydrationInteractionEvent, HydrationInteractionEvents, HydrationMarkerAttributes, HydrationPrefetchContext, HydrationPrefetchFunction, HydrationPrefetchWhen, HydrationPrefetchStrategy, HydrationPrefetchWaitReason, HydrationRuntimeContext, HydrationRuntimeGate, HydrationStrategy, HydrationStrategyTypes, HydrationWhen, } from './hydration/types.js';

package/dist/esm/hydration.js

@@ -0,0 +1,16 @@
+import { hydrateIdAttribute, hydrateInteractionEventsAttribute, hydrateWhenAttribute } from "./hydration/constants.js";
+import { condition } from "./hydration/condition.js";
+import { idle } from "./hydration/idle.js";
+import { clearResolvedGateIdsInMarker, createResolvedGate, getFallbackHtml, getMarkerGate, getOrCreateGate, onGateResolve, releaseGate, resolveHydrationMarker, runHydrationStrategyCleanup, saveFallbackHtml, waitForHydrationPrefetchStrategy } from "./hydration/runtime.js";
+import { interaction, listenForDelegatedHydrationIntent } from "./hydration/interaction.js";
+import { load } from "./hydration/load.js";
+import { media } from "./hydration/media.js";
+import { never } from "./hydration/never.js";
+import { withHydrationRenderer } from "./hydration/renderer.js";
+import { visible } from "./hydration/visible.js";
+//#region src/hydration.ts
+var hydrateIdSelector = `[${hydrateIdAttribute}]`;
+//#endregion
+export { clearResolvedGateIdsInMarker, condition, createResolvedGate, getFallbackHtml, getMarkerGate, getOrCreateGate, hydrateIdAttribute, hydrateIdSelector, hydrateInteractionEventsAttribute, hydrateWhenAttribute, idle, interaction, listenForDelegatedHydrationIntent, load, media, never, onGateResolve, releaseGate, resolveHydrationMarker, runHydrationStrategyCleanup, saveFallbackHtml, visible, waitForHydrationPrefetchStrategy, withHydrationRenderer };
+
+//# sourceMappingURL=hydration.js.map

package/dist/esm/hydration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration.js","names":[],"sources":["../../src/hydration.ts"],"sourcesContent":["import { hydrateIdAttribute } from './hydration/constants'\n\nexport { condition } from './hydration/condition'\nexport type { HydrationCondition } from './hydration/condition'\nexport {\n  hydrateIdAttribute,\n  hydrateInteractionEventsAttribute,\n  hydrateWhenAttribute,\n} from './hydration/constants'\nexport const hydrateIdSelector = `[${hydrateIdAttribute}]`\nexport { idle } from './hydration/idle'\nexport type { IdleHydrationOptions } from './hydration/idle'\nexport { interaction } from './hydration/interaction'\nexport { load } from './hydration/load'\nexport { media } from './hydration/media'\nexport { never } from './hydration/never'\nexport {\n  clearResolvedGateIdsInMarker,\n  createResolvedGate,\n  getFallbackHtml,\n  getMarkerGate,\n  getOrCreateGate,\n  onGateResolve,\n  releaseGate,\n  resolveHydrationMarker,\n  runHydrationStrategyCleanup,\n  saveFallbackHtml,\n  waitForHydrationPrefetchStrategy,\n} from './hydration/runtime'\nexport { withHydrationRenderer } from './hydration/renderer'\nexport { visible } from './hydration/visible'\nexport { listenForDelegatedHydrationIntent } from './hydration/interaction'\nexport type { VisibleHydrationOptions } from './hydration/visible'\nexport type { HydrationGateRecord } from './hydration/runtime'\nexport type { HydrationStrategyWithRenderer } from './hydration/renderer'\nexport type {\n  HydrationInteractionEvent,\n  HydrationInteractionEvents,\n  HydrationMarkerAttributes,\n  HydrationPrefetchContext,\n  HydrationPrefetchFunction,\n  HydrationPrefetchWhen,\n  HydrationPrefetchStrategy,\n  HydrationPrefetchWaitReason,\n  HydrationRuntimeContext,\n  HydrationRuntimeGate,\n  HydrationStrategy,\n  HydrationStrategyTypes,\n  HydrationWhen,\n} from './hydration/types'\n"],"mappings":";;;;;;;;;;;AASA,IAAa,oBAAoB,IAAI,mBAAmB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-client-core",
-  "version": "1.169.4",
+  "version": "1.170.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -44,16 +44,37 @@
         "default": "./dist/esm/client-rpc/index.js"
       }
     },
+    "./hydration": {
+      "import": {
+        "types": "./dist/esm/hydration.d.ts",
+        "default": "./dist/esm/hydration.js"
+      }
+    },
+    "./hydration/constants": {
+      "import": {
+        "types": "./dist/esm/hydration/constants.d.ts",
+        "default": "./dist/esm/hydration/constants.js"
+      }
+    },
+    "./hydration/runtime": {
+      "import": {
+        "types": "./dist/esm/hydration/runtime.d.ts",
+        "default": "./dist/esm/hydration/runtime.js"
+      }
+    },
     "./package.json": "./package.json"
   },
   "imports": {
     "#tanstack-start-entry": {
+      "types": "./src/start-entry.d.ts",
       "default": "./dist/esm/fake-entries/start.js"
     },
     "#tanstack-router-entry": {
+      "types": "./src/start-entry.d.ts",
       "default": "./dist/esm/fake-entries/router.js"
     },
     "#tanstack-start-plugin-adapters": {
+      "types": "./src/start-entry.d.ts",
       "default": "./dist/esm/fake-entries/plugin-adapters.js"
     }
   },
@@ -70,9 +91,9 @@
   },
   "dependencies": {
     "seroval": "^1.5.4",
-    "@tanstack/router-core": "1.171.2",
+    "@tanstack/router-core": "1.171.3",
     "@tanstack/start-fn-stubs": "1.162.0",
-    "@tanstack/start-storage-context": "1.167.4"
+    "@tanstack/start-storage-context": "1.167.5"
   },
   "devDependencies": {
     "vite": "*",

package/src/client/hydrateStart.ts

@@ -1,5 +1,4 @@
 import { hydrate } from '@tanstack/router-core/ssr/client'
-
 import { startInstance } from '#tanstack-start-entry'
 import {
   hasPluginAdapters,
@@ -10,7 +9,19 @@ import { ServerFunctionSerializationAdapter } from './ServerFunctionSerializatio
 import type { AnyRouter, AnySerializationAdapter } from '@tanstack/router-core'
 import type { AnyStartInstanceOptions } from '../createStart'
 
-export async function hydrateStart(): Promise<AnyRouter> {
+type HotContext = {
+  data?: Record<string, unknown>
+  dispose?: (cb: (data: Record<string, unknown>) => void) => void
+}
+
+declare global {
+  interface ImportMeta {
+    hot?: HotContext
+    webpackHot?: HotContext
+  }
+}
+
+async function hydrateStart(): Promise<AnyRouter> {
   const router = await getRouter()
 
   let serializationAdapters: Array<AnySerializationAdapter>
@@ -47,3 +58,38 @@ export async function hydrateStart(): Promise<AnyRouter> {
 
   return router
 }
+
+function hydrateStartWithHmr(): Promise<AnyRouter> {
+  const hot = import.meta.hot ?? import.meta.webpackHot
+
+  if (!hot) {
+    return hydrateStart()
+  }
+
+  const key = 'tss-hydrate-start-promise'
+  const hotData = (hot.data ??= {})
+  let hydrationPromise = hotData[key] as Promise<AnyRouter> | undefined
+
+  if (!hydrationPromise) {
+    hydrationPromise = hydrateStart().catch((error) => {
+      if (hotData[key] === hydrationPromise) {
+        hotData[key] = undefined
+      }
+
+      throw error
+    })
+
+    hotData[key] = hydrationPromise
+  }
+
+  hot.dispose?.((data) => {
+    data[key] = hotData[key]
+  })
+
+  return hydrationPromise
+}
+
+const exportedHydrateStart =
+  process.env.NODE_ENV !== 'production' ? hydrateStartWithHmr : hydrateStart
+
+export { exportedHydrateStart as hydrateStart }

package/src/hydration/condition.ts

@@ -0,0 +1,20 @@
+import type { HydrationStrategy } from './types'
+
+const conditionType = 'condition'
+
+export type HydrationCondition = boolean | (() => boolean)
+
+/* @__NO_SIDE_EFFECTS__ */
+export function condition(
+  condition: HydrationCondition,
+): HydrationStrategy<typeof conditionType, false> {
+  return {
+    _t: conditionType,
+    _d: () => !(typeof condition === 'function' ? condition() : condition),
+    _s: ({ gate }) => {
+      if (typeof condition === 'function' ? condition() : condition) {
+        gate!.resolve()
+      }
+    },
+  }
+}

package/src/hydration/constants.ts

@@ -0,0 +1,4 @@
+export const hydrateIdAttribute = 'data-ts-hydrate-id'
+export const hydrateWhenAttribute = 'data-ts-hydrate-when'
+export const hydrateInteractionEventsAttribute =
+  'data-ts-hydrate-interaction-events'

package/src/hydration/idle.ts

@@ -0,0 +1,35 @@
+import type { HydrationPrefetchStrategy } from './types'
+
+const idleType = 'idle'
+
+export type IdleHydrationOptions = {
+  timeout?: number
+}
+
+export function idle(
+  options: IdleHydrationOptions = {},
+): HydrationPrefetchStrategy<typeof idleType> {
+  const timeout = options.timeout ?? 2000
+
+  return {
+    _t: idleType,
+    _s: ({ gate, prefetch }) => {
+      const schedule = globalThis as unknown as {
+        requestIdleCallback?: (
+          callback: IdleRequestCallback,
+          options?: IdleRequestOptions,
+        ) => number
+        cancelIdleCallback?: (handle: number) => void
+      }
+      const callback = prefetch ?? gate!.resolve
+
+      if (schedule.requestIdleCallback) {
+        const handle = schedule.requestIdleCallback(callback, { timeout })
+        return () => schedule.cancelIdleCallback?.(handle)
+      }
+
+      const timeoutId = globalThis.setTimeout(callback, timeout)
+      return () => globalThis.clearTimeout(timeoutId)
+    },
+  }
+}