redux-sparse-kit 0.0.0-stage → 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aleksandr Khizhnyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,332 @@
-# Temporary Holding Version
+# redux-sparse-kit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/redux-sparse-kit.svg?style=flat-square)](https://www.npmjs.com/package/redux-sparse-kit)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE.md)
+
+Dynamic reducers and epics for large Redux stores: only mounted features run on dispatch.
+
+Every action a Redux store dispatches goes through every reducer, and with
+redux-observable every epic sees it too. In a large application most of that
+work is spent on features that are not on screen. `redux-sparse-kit` keeps the
+store _sparse_: a feature's reducer and epics are injected when the feature
+mounts and evicted some time after it is gone, so the cost of a dispatch
+follows what the user is looking at, not the size of the codebase.
+
+- **Segments** - a reducer, its epics and the segments it depends on, injected
+  and evicted as one unit. Each part is optional.
+- **Reference counting** - a segment stays while anything holds it; shared
+  segments and dependencies are never evicted from under a feature.
+- **Idle eviction** - a released segment waits before it is evicted, so moving
+  back and forth between pages does not tear features down and set them up
+  again. Idle segments can keep running, pause their epics or freeze.
+- **Ordered, atomic changes** - dependencies are injected before their
+  dependents and evicted after them; every batch of changes reaches the store
+  as a single action.
+- **Typed scopes** - an epic that reads a segment its segment does not depend
+  on is a type error.
+- **Scope checks** - in development, reads of a segment's state outside the
+  part of the tree that holds it are reported.
+- **Works with what you have** - a plain store enhancer, usable with
+  `createStore` or Redux Toolkit's `configureStore`, with any root reducer.
+
+## Installation
+
+```bash
+npm install redux-sparse-kit
+# or
+yarn add redux-sparse-kit
+```
+
+`redux` 5 is required. React bindings need `react` 18 or later and
+`react-redux`; epics need `rxjs` 7 and an epic middleware such as
+`redux-observable`. Types need TypeScript 5.4 or later.
+
+## Quick start
+
+### 1. Create the store
+
+```ts
+import {
+  applyMiddleware,
+  combineReducers,
+  compose,
+  legacy_createStore as createStore,
+} from 'redux';
+import type { StoreEnhancer } from 'redux';
+import { createEpicMiddleware } from 'redux-observable';
+import type { SparseStoreExt } from 'redux-sparse-kit';
+import { sparseEnhancer } from 'redux-sparse-kit';
+import { createEpicRunner } from 'redux-sparse-kit/observable';
+
+const epicMiddleware = createEpicMiddleware();
+
+export const store = createStore(
+  // The static state: always present, owned by the root reducer as usual.
+  combineReducers({ session: sessionReducer, router: routerReducer }),
+  // `compose` does not keep the types enhancers add to the store.
+  compose(
+    applyMiddleware(epicMiddleware),
+    sparseEnhancer({ epicRunner: createEpicRunner(epicMiddleware) }),
+  ) as StoreEnhancer<SparseStoreExt>,
+);
+
+epicMiddleware.run(rootEpic);
+```
+
+With Redux Toolkit, which keeps the type of `store.sparse` on its own:
+
+```ts
+const store = configureStore({
+  reducer: { session: sessionReducer, router: routerReducer },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(epicMiddleware),
+  enhancers: (getDefaultEnhancers) =>
+    getDefaultEnhancers().concat(sparseEnhancer({ epicRunner: createEpicRunner(epicMiddleware) })),
+});
+```
+
+### 2. Define segments
+
+```ts
+import { defineSegment } from 'redux-sparse-kit';
+
+export const accountSegment = defineSegment({
+  key: 'account',
+  reducer: accountReducer,
+});
+
+export const ordersSegment = defineSegment({
+  key: 'orders',
+  reducer: ordersReducer,
+  deps: [accountSegment],
+  epics: [loadOrdersEpic],
+});
+```
+
+A segment owns the top-level state key it names. Its dependencies are present
+for as long as it is.
+
+### 3. Hold them where they are used
+
+```tsx
+import { SparseScope } from 'redux-sparse-kit/react';
+
+export function OrdersPage() {
+  return (
+    <SparseScope segments={[ordersSegment]} fallback={<Spinner />}>
+      <OrdersTable />
+    </SparseScope>
+  );
+}
+```
+
+`OrdersTable` renders once `orders` and `account` are in the store, and reads
+them with `useSelector` as usual. When `OrdersPage` unmounts, the segments go
+idle and are evicted a minute later unless something holds them again.
+
+## Segments
+
+```ts
+defineSegment({
+  key: 'orders', // the top-level state key the reducer owns
+  reducer: ordersReducer,
+  deps: [accountSegment], // present for as long as this segment is
+  epics: [loadOrdersEpic], // started after injection, stopped before eviction
+  idleTimeout: 5 * 60_000, // overrides the store's idle timeout
+  whileIdle: 'pause-epics', // overrides the store's idle behaviour
+});
+```
+
+Every part but the key is optional. A segment without a reducer owns no slice
+of the state: it can run epics only, or only bundle the segments it depends on,
+so that one scope holds a whole page.
+
+```ts
+const pricePolling = defineSegment({ key: 'pricePolling', epics: [pollPricesEpic] });
+
+const ordersPage = defineSegment({
+  key: 'ordersPage',
+  deps: [ordersSegment, pricesSegment, pricePolling],
+});
+```
+
+A dependency has to be defined before the segments that list it, so the
+dependency graph cannot have cycles. Two different segments cannot use the same
+key in one store at the same time.
+
+### Typing epics
+
+The state a segment's epics may read is the static state, the segment's own
+slice and the slices of its direct dependencies. An epic that declares a state
+outside of that is rejected:
+
+```ts
+import type { Epic } from 'redux-observable';
+import type { StateOfSegments } from 'redux-sparse-kit';
+
+type OrdersState = StateOfSegments<typeof accountSegment> & { orders: Orders };
+
+const loadOrdersEpic: Epic<Action, Action, OrdersState> = (action$, state$) => /* ... */;
+
+defineSegment({ key: 'orders', reducer: ordersReducer, deps: [accountSegment], epics: [loadOrdersEpic] }); // ok
+defineSegment({ key: 'orders', reducer: ordersReducer, epics: [loadOrdersEpic] }); // error: reads `account`
+```
+
+Epics typed with a `void`, `unknown` or `any` state do not read it and are
+always accepted. Register the static state once to let epics read it too:
+
+```ts
+declare module 'redux-sparse-kit' {
+  interface StaticState {
+    session: SessionState;
+    router: RouterState;
+  }
+}
+```
+
+`ScopeStateOf<typeof segment>` is the full state a segment may read.
+
+## Lifecycle
+
+```
+             acquire                        release (last holder)
+  absent ─────────────▶ active ◀──────────────────────────▶ idle
+     ▲                    ▲          acquire (revive)        │
+     │                    └──────────────────────────────────┤
+     │                                                       │ idle timeout,
+     └───────────────────────── evict ───────────────────────┘ maxIdle
+```
+
+- **Injecting** dispatches `@@sparse/INJECT` with the keys of the slices the
+  call brings in, dependencies first, then starts the epics of the injected
+  segments in that order.
+- **Releasing** the last hold makes a segment idle. Its dependencies stay held
+  by it.
+- **Reviving** an idle segment costs nothing: its slice and epics are still
+  there.
+- **Evicting** stops the epics of the evicted segments, dependents first, then
+  dispatches `@@sparse/EVICT`, which removes their slices.
+- Segments without a reducer add and remove no slice: when a change involves
+  only such segments, no action is dispatched. Dependencies that
+  only the evicted segments held are evicted in the same action. Segments that
+  expire together are swept together, when the browser is idle.
+
+Reducers outside the segments can handle `SparseActionTypes.EVICT` to drop
+data that refers to an evicted segment. A preloaded slice for a segment that is
+not present yet is kept, and the segment starts from it when injected.
+
+## Store options
+
+```ts
+sparseEnhancer({
+  epicRunner, // required once a held segment has epics
+  idleTimeout: 60_000, // ms a released segment waits; 0 = evict now, Infinity = never
+  whileIdle: 'keep-running', // what an idle segment does
+  maxIdle: Infinity, // idle segments kept at most; the least recently used go first
+  pauseWhenHidden: true, // stop the idle clock while the page is hidden
+});
+```
+
+| `whileIdle`    | Reducer | Epics   | Use for                                               |
+| -------------- | ------- | ------- | ----------------------------------------------------- |
+| `keep-running` | runs    | run     | data kept current by a stream, e.g. live quotes       |
+| `pause-epics`  | runs    | stopped | epics that hold subscriptions or poll; restart on use |
+| `freeze`       | skipped | stopped | state that is cheap to keep but costly to update      |
+
+A frozen segment resumes from the state it had when it went idle, so actions
+dispatched in the meantime are lost to it.
+
+## The store API
+
+`sparseEnhancer` adds `store.sparse`:
+
+```ts
+const release = store.sparse.acquire(ordersSegment, pricesSegment);
+release(); // idempotent
+
+store.sparse.has(ordersSegment); // or has('orders')
+store.sparse.stats(); // { active: ['orders', 'account'], idle: ['prices'] }
+
+store.sparse.batch(() => {
+  // injections and evictions caused in here reach the store as one action each
+});
+
+const unsubscribe = store.sparse.subscribe((event) => {
+  // { type: 'inject' | 'evict', keys } | { type: 'idle' | 'revive', key }
+});
+```
+
+`acquire` is all or nothing: if any of the segments, or their dependencies,
+conflicts with a different segment already using its key, it throws and holds
+nothing.
+
+## React
+
+```ts
+import { SparseScope, useSparseSegments, createSparseReact } from 'redux-sparse-kit/react';
+```
+
+- `<SparseScope segments fallback>` holds the segments while mounted and
+  renders its children once they are present. Segments still present from an
+  earlier visit render straight away. Holding happens in a layout effect, so
+  the fallback never reaches the screen when the segments can be injected
+  right away.
+- `useSparseSegments(segments)` holds the segments while the calling component
+  is mounted and returns whether they are present yet.
+- A new array of the same segments on every render does not acquire them
+  again.
+
+The bindings find the store in react-redux's context, so they work with any
+react-redux 8.1 or later. Pass `createSparseReact({ context })` when the
+`<Provider>` was given a custom context.
+
+### Scope checks
+
+In development, `SparseScope` reports reads of a segment's slice made outside
+every scope that holds it: such a read works only while some other part of the
+tree happens to hold the segment, and breaks once it is evicted.
+
+```tsx
+<Provider store={store}>
+  {/* reports reads below that no scope holds */}
+  <SparseScope segments={[]}>
+    <App />
+  </SparseScope>
+</Provider>
+```
+
+A scope makes its segments and their dependencies available to everything
+below it, including nested scopes. Reads of static state are never reported.
+
+By default each key is logged once per selector with `console.error`. Pass a
+handler to collect them instead, for example to fail end-to-end tests:
+
+```ts
+const { SparseScope } = createSparseReact({
+  onViolation: ({ key, selector, scope }) => violations.push({ key, selector, scope }),
+  checks: true, // default: on outside production builds
+});
+```
+
+How reads are observed depends on react-redux. When its context value carries
+`stateAccessTracking: true`, react-redux reports the first read of each
+top-level key by each selector through an `onStateAccess(key, selector)`
+callback on the context value; scopes replace that callback for their subtree
+and report the selector that made the read. Otherwise scopes pass down a
+wrapper of the store whose state is a proxy that sees each top-level read; the
+selector is then not known. Checks are compiled out of production builds that
+replace `process.env.NODE_ENV`.
+
+## Caveats
+
+- **Server rendering** - segments are injected on the client. On the server
+  `SparseScope` renders its fallback.
+- **`connect`** - with `onStateAccess`, reads made by `connect` are not
+  reported: react-redux reports only the reads of `useSelector`. With the store
+  wrapper they are.
+- **Reading the whole state** - with the store wrapper, a selector that spreads
+  or iterates the whole state reads every key and is reported for each
+  segment slice.
+
+## License
+
+[MIT](LICENSE.md)

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { _ as StaticState, a as SparseEvent, b as isSegmentKey, c as SparseStoreExt, d as ScopeStateOf, f as Segment, g as StateOfSegments, h as SegmentOptions, i as SparseController, l as sparseEnhancer, m as SegmentEpicStateError, n as SparseAction, o as SparseOptions, p as SegmentEpic, r as SparseActionTypes, s as SparseStats, t as EpicRunner, u as AnySegment, v as WhileIdle, y as defineSegment } from "./sparseEnhancer-CIcdhh-P.mjs";
+export { type AnySegment, type EpicRunner, type ScopeStateOf, type Segment, type SegmentEpic, type SegmentEpicStateError, type SegmentOptions, type SparseAction, SparseActionTypes, type SparseController, type SparseEvent, type SparseOptions, type SparseStats, type SparseStoreExt, type StateOfSegments, type StaticState, type WhileIdle, defineSegment, isSegmentKey, sparseEnhancer };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { _ as StaticState, a as SparseEvent, b as isSegmentKey, c as SparseStoreExt, d as ScopeStateOf, f as Segment, g as StateOfSegments, h as SegmentOptions, i as SparseController, l as sparseEnhancer, m as SegmentEpicStateError, n as SparseAction, o as SparseOptions, p as SegmentEpic, r as SparseActionTypes, s as SparseStats, t as EpicRunner, u as AnySegment, v as WhileIdle, y as defineSegment } from "./sparseEnhancer-CIcdhh-P.js";
+export { type AnySegment, type EpicRunner, type ScopeStateOf, type Segment, type SegmentEpic, type SegmentEpicStateError, type SegmentOptions, type SparseAction, SparseActionTypes, type SparseController, type SparseEvent, type SparseOptions, type SparseStats, type SparseStoreExt, type StateOfSegments, type StaticState, type WhileIdle, defineSegment, isSegmentKey, sparseEnhancer };

package/dist/index.js

@@ -0,0 +1,336 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_segment = require("./segment-Dqd6-ABS.js");
+//#region src/sparseEnhancer.ts
+/**
+* Actions the sparse store dispatches. Reducers outside the segments can
+* handle {@linkcode SparseActionTypes.EVICT} to drop data that refers to an
+* evicted segment.
+*/
+const SparseActionTypes = {
+	/** Segment slices with the keys in `payload.keys` were added to the state. */
+	INJECT: "@@sparse/INJECT",
+	/** Segment slices with the keys in `payload.keys` are removed by this action. */
+	EVICT: "@@sparse/EVICT"
+};
+const emptyKeys = /* @__PURE__ */ new Set();
+const defaultIdleTimeout = 6e4;
+const whileIdleValues = [
+	"keep-running",
+	"pause-epics",
+	"freeze"
+];
+const maxTimerDelay = 2 ** 31 - 1;
+const scheduleIdle = (callback) => {
+	if (typeof requestIdleCallback === "function") requestIdleCallback(callback, { timeout: 1e3 });
+	else setTimeout(callback, 0);
+};
+/**
+* A store enhancer that lets segments be injected into and evicted from a
+* running store. The root reducer passed to `createStore` keeps owning the
+* static state; segment slices live next to it under their keys.
+*/
+function sparseEnhancer(options = {}) {
+	const { epicRunner, idleTimeout = defaultIdleTimeout, whileIdle = "keep-running", maxIdle = Infinity, pauseWhenHidden = true } = options;
+	const isHidden = () => pauseWhenHidden && typeof document !== "undefined" && document.visibilityState === "hidden";
+	if (!(idleTimeout >= 0)) throw new RangeError("The idle timeout must be a non-negative number");
+	if (!(maxIdle >= 0)) throw new RangeError("maxIdle must be a non-negative number");
+	if (!whileIdleValues.includes(whileIdle)) throw new RangeError(`whileIdle must be one of ${whileIdleValues.join(", ")}`);
+	const enhancer = (createStore) => (rootReducer, preloadedState) => {
+		const entries = /* @__PURE__ */ new Map();
+		const idleEntries = /* @__PURE__ */ new Set();
+		let evictingKeys = emptyKeys;
+		const slices = /* @__PURE__ */ new Map();
+		const isDynamicKey = (key) => slices.has(key) || evictingKeys.has(key) || require_segment.isSegmentKey(key);
+		const wrapReducer = (root) => (state, action) => {
+			var _staticState;
+			const current = state !== null && state !== void 0 ? state : {};
+			let staticState;
+			let hasDynamicKeys = false;
+			for (const key in current) if (isDynamicKey(key)) {
+				hasDynamicKeys = true;
+				break;
+			}
+			if (hasDynamicKeys) {
+				staticState = {};
+				for (const key in current) if (!isDynamicKey(key)) staticState[key] = current[key];
+			}
+			const input = state === void 0 ? void 0 : (_staticState = staticState) !== null && _staticState !== void 0 ? _staticState : current;
+			const nextStatic = root(input, action);
+			let changed = nextStatic !== input || evictingKeys.size > 0;
+			const values = [];
+			for (const [key, entry] of slices) {
+				const previous = current[key];
+				const value = entry.frozen && key in current ? previous : entry.segment.reducer(previous, action);
+				values.push(value);
+				if (value !== previous || !(key in current)) changed = true;
+			}
+			if (!changed) return current;
+			const next = { ...nextStatic };
+			for (const key in current) if (!slices.has(key) && !evictingKeys.has(key) && require_segment.isSegmentKey(key)) next[key] = current[key];
+			let index = 0;
+			for (const key of slices.keys()) next[key] = values[index++];
+			return next;
+		};
+		const store = createStore(wrapReducer(rootReducer), preloadedState);
+		let batchDepth = 0;
+		const pendingInject = [];
+		const pendingEvict = [];
+		const listeners = /* @__PURE__ */ new Set();
+		const emit = (event) => {
+			for (const listener of listeners) listener(event);
+		};
+		const dispatchSparse = (type, keys) => {
+			const action = {
+				type,
+				payload: { keys }
+			};
+			store.dispatch(action);
+		};
+		const flush = () => {
+			if (batchDepth > 0) return;
+			if (pendingInject.length > 0) {
+				const injected = pendingInject.splice(0);
+				const keys = injected.map((entry) => entry.segment.key);
+				const sliceKeys = [];
+				for (const entry of injected) if (entry.segment.reducer) {
+					slices.set(entry.segment.key, entry);
+					sliceKeys.push(entry.segment.key);
+				}
+				if (sliceKeys.length > 0) dispatchSparse(SparseActionTypes.INJECT, sliceKeys);
+				for (const entry of injected) if (!entry.paused) startEpics(entry);
+				emit({
+					type: "inject",
+					keys
+				});
+			}
+			if (pendingEvict.length > 0) {
+				const evicted = pendingEvict.splice(0);
+				const keys = evicted.map((entry) => entry.segment.key);
+				for (const entry of evicted) stopEpics(entry);
+				const sliceKeys = keys.filter((key) => slices.delete(key));
+				if (sliceKeys.length > 0) {
+					evictingKeys = new Set(sliceKeys);
+					try {
+						dispatchSparse(SparseActionTypes.EVICT, sliceKeys);
+					} finally {
+						evictingKeys = emptyKeys;
+					}
+				}
+				emit({
+					type: "evict",
+					keys
+				});
+			}
+		};
+		const startEpics = (entry) => {
+			for (const epic of entry.segment.epics) entry.stops.push(epicRunner.run(epic, entry.segment));
+		};
+		const stopEpics = (entry) => {
+			for (const stop of entry.stops.splice(0)) stop();
+		};
+		const batch = (fn) => {
+			batchDepth++;
+			try {
+				return fn();
+			} finally {
+				batchDepth--;
+				flush();
+			}
+		};
+		const assertCompatible = (segment, seen) => {
+			var _seen$get, _entries$get;
+			const other = (_seen$get = seen.get(segment.key)) !== null && _seen$get !== void 0 ? _seen$get : (_entries$get = entries.get(segment.key)) === null || _entries$get === void 0 ? void 0 : _entries$get.segment;
+			if (other === segment) return;
+			if (other !== void 0) throw new Error(`Two different segments use the key "${segment.key}"`);
+			if (segment.epics.length > 0 && epicRunner === void 0) throw new Error(`Segment "${segment.key}" has epics, but sparseEnhancer was created without an epicRunner`);
+			seen.set(segment.key, segment);
+			for (const dep of segment.deps) assertCompatible(dep, seen);
+		};
+		const hold = (segment) => {
+			const existing = entries.get(segment.key);
+			if (existing) {
+				if (existing.holders === 0) revive(existing);
+				existing.holders++;
+				return;
+			}
+			const evictIndex = pendingEvict.findIndex((entry) => entry.segment === segment);
+			if (evictIndex !== -1) {
+				const [entry] = pendingEvict.splice(evictIndex, 1);
+				entry.holders = 1;
+				entries.set(segment.key, entry);
+				for (const dep of segment.deps) hold(dep);
+				return;
+			}
+			const entry = {
+				segment,
+				holders: 1,
+				stops: [],
+				timer: void 0,
+				remaining: Infinity,
+				startedAt: 0,
+				expired: false,
+				paused: false,
+				frozen: false
+			};
+			entries.set(segment.key, entry);
+			for (const dep of segment.deps) hold(dep);
+			pendingInject.push(entry);
+		};
+		/**
+		* Drops a hold. A segment left without holders goes idle, unless it was
+		* only held by a segment being evicted: then it is evicted with it.
+		*/
+		const unhold = (segment, cascade = false) => {
+			var _segment$idleTimeout;
+			const entry = entries.get(segment.key);
+			entry.holders--;
+			if (entry.holders > 0) return;
+			const timeout = (_segment$idleTimeout = segment.idleTimeout) !== null && _segment$idleTimeout !== void 0 ? _segment$idleTimeout : idleTimeout;
+			if (cascade || timeout === 0) evict(entry);
+			else becomeIdle(entry, timeout);
+		};
+		const becomeIdle = (entry, timeout) => {
+			var _entry$segment$whileI;
+			const policy = (_entry$segment$whileI = entry.segment.whileIdle) !== null && _entry$segment$whileI !== void 0 ? _entry$segment$whileI : whileIdle;
+			if (policy !== "keep-running") {
+				entry.paused = true;
+				entry.frozen = policy === "freeze";
+				stopEpics(entry);
+			}
+			entry.remaining = timeout > maxTimerDelay ? Infinity : timeout;
+			if (!isHidden()) startTimer(entry);
+			idleEntries.add(entry);
+			watchVisibility();
+			emit({
+				type: "idle",
+				key: entry.segment.key
+			});
+			while (idleEntries.size > maxIdle) evict(idleEntries.values().next().value);
+		};
+		const startTimer = (entry) => {
+			if (entry.remaining !== Infinity) {
+				entry.startedAt = Date.now();
+				entry.timer = setTimeout(() => {
+					entry.timer = void 0;
+					entry.expired = true;
+					scheduleSweep();
+				}, entry.remaining);
+			}
+		};
+		const pauseTimers = () => {
+			for (const entry of idleEntries) if (entry.timer !== void 0) {
+				clearTimeout(entry.timer);
+				entry.timer = void 0;
+				entry.remaining = Math.max(0, entry.remaining - (Date.now() - entry.startedAt));
+			}
+		};
+		const resumeTimers = () => {
+			for (const entry of idleEntries) if (entry.timer === void 0 && !entry.expired) startTimer(entry);
+		};
+		const onVisibilityChange = () => {
+			if (isHidden()) pauseTimers();
+			else resumeTimers();
+		};
+		let watchingVisibility = false;
+		/** Listens to the page visibility only while there are idle segments. */
+		const watchVisibility = () => {
+			const watch = idleEntries.size > 0;
+			if (watch !== watchingVisibility && pauseWhenHidden && typeof document !== "undefined") {
+				watchingVisibility = watch;
+				if (watch) document.addEventListener("visibilitychange", onVisibilityChange);
+				else document.removeEventListener("visibilitychange", onVisibilityChange);
+			}
+		};
+		const revive = (entry) => {
+			idleEntries.delete(entry);
+			watchVisibility();
+			clearTimeout(entry.timer);
+			entry.timer = void 0;
+			entry.expired = false;
+			entry.frozen = false;
+			if (entry.paused) {
+				entry.paused = false;
+				if (!pendingInject.includes(entry)) startEpics(entry);
+			}
+			emit({
+				type: "revive",
+				key: entry.segment.key
+			});
+		};
+		const evict = (entry) => {
+			idleEntries.delete(entry);
+			watchVisibility();
+			clearTimeout(entry.timer);
+			entries.delete(entry.segment.key);
+			const pendingIndex = pendingInject.indexOf(entry);
+			if (pendingIndex !== -1) pendingInject.splice(pendingIndex, 1);
+			else pendingEvict.push(entry);
+			for (const dep of entry.segment.deps) unhold(dep, true);
+		};
+		let sweepScheduled = false;
+		/** Evicts every expired segment with a single action. */
+		const sweep = () => {
+			sweepScheduled = false;
+			batch(() => {
+				for (const entry of entries.values()) if (entry.expired) evict(entry);
+			});
+		};
+		const scheduleSweep = () => {
+			if (!sweepScheduled) {
+				sweepScheduled = true;
+				scheduleIdle(sweep);
+			}
+		};
+		const sparse = {
+			acquire(...segments) {
+				const seen = /* @__PURE__ */ new Map();
+				for (const segment of segments) assertCompatible(segment, seen);
+				batch(() => {
+					for (const segment of segments) hold(segment);
+				});
+				let released = false;
+				return () => {
+					if (released) return;
+					released = true;
+					batch(() => {
+						for (const segment of segments) unhold(segment);
+					});
+				};
+			},
+			has(segmentOrKey) {
+				const key = typeof segmentOrKey === "string" ? segmentOrKey : segmentOrKey.key;
+				return entries.has(key) && !pendingInject.includes(entries.get(key));
+			},
+			stats() {
+				const stats = {
+					active: [],
+					idle: []
+				};
+				for (const [key, entry] of entries) if (!pendingInject.includes(entry)) (entry.holders > 0 ? stats.active : stats.idle).push(key);
+				return stats;
+			},
+			batch,
+			subscribe(listener) {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			}
+		};
+		return {
+			...store,
+			replaceReducer(nextReducer) {
+				store.replaceReducer(wrapReducer(nextReducer));
+			},
+			sparse
+		};
+	};
+	return enhancer;
+}
+//#endregion
+exports.SparseActionTypes = SparseActionTypes;
+exports.defineSegment = require_segment.defineSegment;
+exports.isSegmentKey = require_segment.isSegmentKey;
+exports.sparseEnhancer = sparseEnhancer;
+
+//# sourceMappingURL=index.js.map