@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.
71 lines (70 loc) • 3.38 kB
JavaScript
import { resolveSelectorFlushManager } from "../selector-core/throttled-selector-options.js";
import { createCachedSelector } from "../selector-core/create-cached-selector.js";
import { areStoreUpdatesLocked } from "../selector-core/store-update-lock.js";
import { createThrottledObservable } from "./selector-scheduler.js";
import { select } from "typed-redux-saga";
import Kefir from "kefir";
//#region src/utils/streaming-selectors/create-selector.ts
var isKefirObservable = (arg) => {
if (!arg || typeof arg !== "object") return false;
return "observe" in arg && typeof arg.observe === "function";
};
var isStreamingStateSource = (arg) => {
if (!arg || typeof arg !== "object") return false;
return "getStreamState" in arg && typeof arg.getStreamState === "function";
};
var toKefirObservable = (arg) => {
if (isKefirObservable(arg)) return arg;
return Kefir.constant(arg);
};
var resolveStreamState = (store) => {
if (isKefirObservable(store)) return store;
return store.getStreamState();
};
var createSelectorFromStreamState = (getStreamState, selectorFunc, selectorFlushManagerOrFrequency = 64, traceReporter) => {
const selectorFlushManager = typeof selectorFlushManagerOrFrequency === "function" ? void 0 : resolveSelectorFlushManager(selectorFlushManagerOrFrequency);
const getSelectorFlushManager = () => selectorFlushManager ?? resolveSelectorFlushManager(selectorFlushManagerOrFrequency);
const boundSelector = (streamStoreState, ...restArgs) => {
const cachedSelector = createCachedSelector(selectorFunc, {
lockUpdatesPredicate: areStoreUpdatesLocked,
traceReporter
});
const combinedArgs = [streamStoreState, ...restArgs.map(toKefirObservable)];
return createThrottledObservable(Kefir.combine(combinedArgs).map(([storeState, ...args]) => {
return cachedSelector(storeState, ...args);
}), getSelectorFlushManager()).toProperty();
};
const streamSelector = ((...restArgs) => {
return boundSelector(getStreamState(), ...restArgs);
});
streamSelector.withStore = (store) => {
return (...args) => boundSelector(resolveStreamState(store), ...args);
};
streamSelector.select = selectorFunc;
streamSelector.effect = (...args) => {
return select(selectorFunc, ...args);
};
return streamSelector;
};
var createSelectorImpl = (store, selectorFunc) => {
if (!isStreamingStateSource(store)) throw new TypeError("createSelector requires a streaming state source as the first argument.");
if (typeof selectorFunc !== "function") throw new TypeError("createSelector requires a selector function as the second argument.");
return createSelectorFromStreamState(() => store.getStreamState(), selectorFunc);
};
var createSelector = createSelectorImpl;
var createCollectionItemSelector = (store, collectionSelector) => {
return createSelector(store, (state, itemId) => {
if (!itemId) return void 0;
return collectionSelector(state).map[itemId];
});
};
var createCollectionItemsListSelector = (store, collectionSelector, itemFilter) => {
return createSelector(store, (state) => {
const { map, ids } = collectionSelector(state);
const list = ids.map((id) => map[id]);
return itemFilter ? list.filter(itemFilter) : list;
});
};
//#endregion
export { createCachedSelector, createCollectionItemSelector, createCollectionItemsListSelector, createSelector, createSelectorFromStreamState };
//# sourceMappingURL=create-selector.js.map