@augmentcode/ag-redux-toolkit
Version:
Redux + Saga state management for Svelte apps — designed for AI agents. Includes runtime TypeScript source, AI skills, and reference documentation for robust, observable, high-performance state management.
142 lines (141 loc) • 4.85 kB
JavaScript
import { INTERNAL_STORE_UTILITY_DOMAIN } from "../store/store-runtime-constants.js";
import { createCachedSelector } from "../selector-core/create-cached-selector.js";
import { shallowEqual } from "fast-equals";
import { eventChannel } from "redux-saga";
import { cancel, fork, getContext, take } from "typed-redux-saga";
//#region src/utils/sagas/selector-channel-effects.ts
/**
* Saga effects for working with selector channels.
*
* These effects provide a safer, more ergonomic way to react to selector changes in sagas.
* They automatically handle channel creation and cleanup, preventing memory leaks from
* unclosed eventChannel subscriptions.
*
* Usage:
* ```typescript
* // Instead of:
* const channel = yield* createChannelFromSelector(mySelector, arg);
* try {
* yield* takeEvery(channel, function*({ payload }) { ... });
* } finally {
* channel.close();
* }
*
* // Use (with args):
* yield* takeEveryFromSelector(mySelector, [arg], function*({ payload }) { ... });
*
* // Use (without args):
* yield* takeEveryFromSelector(mySelector, function*({ payload }) { ... });
* ```
*
* These effects automatically fork themselves, so you don't need to wrap them in fork().
*/
/**
* Creates an event channel from a selector that emits when the selector value changes.
* The channel must be closed when no longer needed to prevent memory leaks.
*
* Usage:
* ```typescript
* const channel = yield* createChannelFromSelector(mySelector, arg1, arg2);
* try {
* while (true) {
* const { payload, prevPayload } = yield* take(channel);
* // handle value change
* }
* } finally {
* channel.close();
* }
* ```
*
* @param selector - The store selector to watch
* @param args - Arguments to pass to the selector
* @returns An event channel that emits { payload, prevPayload } on value changes
*/
function* createChannelFromSelector(selector, ...args) {
const reduxStore = yield* getContext("reduxStore");
if (!reduxStore) throw new Error("No Redux Store available in saga");
const selectorFunc = selector.select;
return eventChannel((emitter) => {
const cachedSelector = createCachedSelector(selectorFunc, { lockUpdatesPredicate: (state) => state[INTERNAL_STORE_UTILITY_DOMAIN]?.updatesLocked === true });
let prevValue = null;
const emitCurrentValue = () => {
try {
const payload = cachedSelector(reduxStore.getState(), ...args);
if (shallowEqual(prevValue, payload)) return;
emitter({
payload,
prevPayload: prevValue
});
prevValue = payload;
} catch (e) {
console.error("Selector channel error", e);
}
};
const unsubscribe = reduxStore.subscribe(emitCurrentValue);
emitCurrentValue();
return unsubscribe;
});
}
/**
* Internal implementation for takeEvery pattern with selector channels.
*/
function* takeEveryFromSelectorImpl(selector, args, worker) {
const channel = yield* createChannelFromSelector(selector, ...args);
try {
while (true) yield* fork(worker, yield* take(channel));
} finally {
channel.close();
}
}
function* takeEveryFromSelector(selector, argsOrWorker, worker) {
return yield* fork(takeEveryFromSelectorImpl, selector, typeof argsOrWorker === "function" ? [] : argsOrWorker, typeof argsOrWorker === "function" ? argsOrWorker : worker);
}
/**
* Internal implementation for takeLatest pattern with selector channels.
*/
function* takeLatestFromSelectorImpl(selector, args, worker) {
const channel = yield* createChannelFromSelector(selector, ...args);
let lastTask = null;
try {
while (true) {
const payload = yield* take(channel);
if (lastTask) yield* cancel(lastTask);
lastTask = yield* fork(worker, payload);
}
} finally {
channel.close();
}
}
function* takeLatestFromSelector(selector, argsOrWorker, worker) {
return yield* fork(takeLatestFromSelectorImpl, selector, typeof argsOrWorker === "function" ? [] : argsOrWorker, typeof argsOrWorker === "function" ? argsOrWorker : worker);
}
/**
* Internal implementation for takeLeading pattern with selector channels.
*/
function* takeLeadingFromSelectorImpl(selector, args, worker) {
const channel = yield* createChannelFromSelector(selector, ...args);
let isRunning = false;
try {
while (true) {
const payload = yield* take(channel);
if (!isRunning) {
isRunning = true;
yield* fork(function* () {
try {
yield* worker(payload);
} finally {
isRunning = false;
}
});
}
}
} finally {
channel.close();
}
}
function* takeLeadingFromSelector(selector, argsOrWorker, worker) {
return yield* fork(takeLeadingFromSelectorImpl, selector, typeof argsOrWorker === "function" ? [] : argsOrWorker, typeof argsOrWorker === "function" ? argsOrWorker : worker);
}
//#endregion
export { createChannelFromSelector, takeEveryFromSelector, takeLatestFromSelector, takeLeadingFromSelector };
//# sourceMappingURL=selector-channel-effects.js.map