@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.
70 lines (69 loc) • 3.42 kB
JavaScript
import { createStoreStateReadable } from "./create-readable-store-state.js";
import { resolveSelectorFlushManager } from "../selector-core/throttled-selector-options.js";
import { createThrottledReadable } from "./selector-scheduler.js";
import { createCachedSelector } from "../selector-core/create-cached-selector.js";
import { areStoreUpdatesLocked } from "../selector-core/store-update-lock.js";
import { select } from "typed-redux-saga";
import { derived, readable } from "svelte/store";
//#region src/utils/svelte-selectors/create-selector.ts
var isReadable = (arg) => {
if (!arg || typeof arg !== "object") return false;
return "subscribe" in arg && typeof arg.subscribe === "function";
};
var isReadableStateSource = (arg) => {
if (!arg || typeof arg !== "object") return false;
return "getReadableState" in arg && typeof arg.getReadableState === "function";
};
var resolveReadableState = (store) => {
if (isReadableStateSource(store)) return store.getReadableState();
return createStoreStateReadable(store);
};
var createSelectorFromReadableState = (getReadableState, selectorFunc, selectorFlushManagerOrFrequency = 64, traceReporter) => {
const selectorFlushManager = typeof selectorFlushManagerOrFrequency === "function" ? void 0 : resolveSelectorFlushManager(selectorFlushManagerOrFrequency);
const getSelectorFlushManager = () => selectorFlushManager ?? resolveSelectorFlushManager(selectorFlushManagerOrFrequency);
const boundSelector = (readableStoreState, ...restArgs) => {
const cachedSelector = createCachedSelector(selectorFunc, {
lockUpdatesPredicate: areStoreUpdatesLocked,
traceReporter
});
return createThrottledReadable(derived([readableStoreState, ...restArgs.map((arg) => {
if (isReadable(arg)) return arg;
return readable(arg);
})], ([storeState, ...args]) => {
return cachedSelector(storeState, ...args);
}), getSelectorFlushManager());
};
const readableSelector = ((...restArgs) => {
return boundSelector(getReadableState(), ...restArgs);
});
readableSelector.withStore = (store) => (...args) => {
return boundSelector(resolveReadableState(store), ...args);
};
readableSelector.select = selectorFunc;
readableSelector.effect = (...args) => {
return select(selectorFunc, ...args);
};
return readableSelector;
};
var createSelectorImpl = (store, selectorFunc) => {
if (!isReadableStateSource(store)) throw new TypeError("createSelector requires a Store instance as the first argument.");
if (typeof selectorFunc !== "function") throw new TypeError("createSelector requires a selector function as the second argument.");
return createSelectorFromReadableState(() => store.getReadableState(), 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, createSelectorFromReadableState };
//# sourceMappingURL=create-selector.js.map