@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.
76 lines (75 loc) • 3.45 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 { createThrottledSignal } from "./selector-scheduler.js";
import { computed } from "@preact/signals-react";
import { select } from "typed-redux-saga";
import { useSignals } from "@preact/signals-react/runtime";
//#region src/utils/react-selectors/create-selector.ts
var isSignal = (arg) => {
if (!arg || typeof arg !== "object") return false;
return "subscribe" in arg && typeof arg.subscribe === "function" && "value" in arg;
};
var isSignalStateSource = (arg) => {
if (!arg || typeof arg !== "object") return false;
return "getSignalState" in arg && typeof arg.getSignalState === "function";
};
var resolveSignalState = (store) => {
if (isSignal(store)) return store;
return store.getSignalState();
};
var readSignalArg = (arg) => {
if (isSignal(arg)) return arg.value;
return arg;
};
var createSelectorFromSignalState = (getSignalState, selectorFunc, selectorFlushManagerOrFrequency = 64, traceReporter) => {
const selectorFlushManager = typeof selectorFlushManagerOrFrequency === "function" ? void 0 : resolveSelectorFlushManager(selectorFlushManagerOrFrequency);
const getSelectorFlushManager = () => selectorFlushManager ?? resolveSelectorFlushManager(selectorFlushManagerOrFrequency);
const boundSelector = (signalStoreState, ...restArgs) => {
const cachedSelector = createCachedSelector(selectorFunc, {
lockUpdatesPredicate: areStoreUpdatesLocked,
traceReporter
});
return createThrottledSignal(computed(() => {
const args = restArgs.map(readSignalArg);
return cachedSelector(signalStoreState.value, ...args);
}), getSelectorFlushManager());
};
const signalSelector = ((...restArgs) => {
return boundSelector(getSignalState(), ...restArgs);
});
signalSelector.useValue = (...args) => {
useSignals();
return signalSelector(...args).value;
};
signalSelector.withStore = (store) => {
return (...args) => boundSelector(resolveSignalState(store), ...args);
};
signalSelector.select = selectorFunc;
signalSelector.effect = (...args) => {
return select(selectorFunc, ...args);
};
return signalSelector;
};
var createSelectorImpl = (store, selectorFunc) => {
if (!isSignalStateSource(store)) throw new TypeError("createSelector requires a signal state source as the first argument.");
if (typeof selectorFunc !== "function") throw new TypeError("createSelector requires a selector function as the second argument.");
return createSelectorFromSignalState(() => store.getSignalState(), 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, createSelectorFromSignalState };
//# sourceMappingURL=create-selector.js.map