@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.
178 lines (177 loc) • 6.98 kB
JavaScript
import { INTERNAL_STORE_UTILITY_DOMAIN } from "./utils/store/store-runtime-constants.js";
import { deriveSagaName } from "./utils/sagas/derive-saga-name.js";
import { sagaManagerReducer, startSaga, stopSaga } from "./slices/saga-manager/saga-manager-slice.js";
import { INTERNAL_SAGA_MANAGER_NAME } from "./constants.js";
import { registerGlobalDevTools } from "./global-dev-tools.js";
import { createSelectorFlushManager } from "./utils/selector-core/throttled-selector-options.js";
import { renderAccessedPaths } from "./utils/selector-core/create-cached-selector.js";
import { storeUtilityReducer } from "./slices/store-utility/store-utility-slice.js";
import { sagaManager } from "./slices/saga-manager/sagas/manager.js";
import { normalizeStoreOptions } from "./store-options.js";
import { applyMiddleware, combineReducers, legacy_createStore } from "redux";
import createSagaMiddleware from "redux-saga";
//#region src/store-runtime.ts
var MAX_SELECTOR_SOURCE_SNIPPET_LINES = 5;
var MAX_SELECTOR_SOURCE_SNIPPET_LENGTH = 500;
var getSelectorSourceSnippet = (selectorFunc) => {
return selectorFunc.toString().split(/\r?\n/).slice(0, MAX_SELECTOR_SOURCE_SNIPPET_LINES).join("\n").slice(0, MAX_SELECTOR_SOURCE_SNIPPET_LENGTH);
};
var createStoreSagaMonitor = () => ({
effectTriggered(event) {
console.info("[ag-redux-toolkit:saga] effectTriggered", event);
},
effectResolved(effectId, result) {
console.info("[ag-redux-toolkit:saga] effectResolved", effectId, result);
},
effectRejected(effectId, error) {
console.info("[ag-redux-toolkit:saga] effectRejected", effectId, error);
},
effectCancelled(effectId) {
console.info("[ag-redux-toolkit:saga] effectCancelled", effectId);
},
actionDispatched(action) {
console.info("[ag-redux-toolkit:saga] actionDispatched", action);
}
});
var StoreRuntime = class {
reducers = {
[INTERNAL_STORE_UTILITY_DOMAIN]: storeUtilityReducer,
[INTERNAL_SAGA_MANAGER_NAME]: sagaManagerReducer
};
middlewares = [];
sagaMiddleware;
tasksStarted = [];
storeContext;
selectorFlushManager;
disposeDevTools;
selectorTracingEnabled = false;
maxLoggedSelectorAccessedPathCount;
storeOptions;
constructor(reducersMap, middleware, options) {
this.storeOptions = normalizeStoreOptions(options);
this.sagaMiddleware = this.storeOptions.sagaMonitor ? createSagaMiddleware({ sagaMonitor: createStoreSagaMonitor() }) : createSagaMiddleware();
for (const [name, reducer] of Object.entries(reducersMap ?? {})) this.registerReducer(name, reducer);
if (middleware !== void 0) this.addMiddleware(middleware);
}
registerReducer(name, reducer) {
const reducers = this.reducers;
if (reducers[name] !== void 0) throw new Error(`Reducer "${name}" is already added. Each reducer name must be unique.`);
reducers[name] = reducer;
}
addMiddleware(middleware) {
if (Array.isArray(middleware)) this.middlewares.push(...middleware);
else this.middlewares.push(middleware);
}
getMiddlewarePipeline() {
return [...this.middlewares, this.sagaMiddleware];
}
runSagaSafely(saga, ...args) {
const task = this.sagaMiddleware.run(saga, ...args);
this.tasksStarted.push(task);
return task;
}
createExtendedDefaultState(initialState) {
const reducers = this.reducers;
return Object.keys(reducers).reduce((state, domain) => {
return {
...state,
[domain]: {
...reducers[domain].initialState,
...initialState ? initialState[domain] : {}
}
};
}, {});
}
stopSagas() {
for (const task of this.tasksStarted) task.cancel();
this.tasksStarted = [];
}
getOrCreateSelectorFlushManager() {
if (!this.selectorFlushManager) this.selectorFlushManager = createSelectorFlushManager(this.storeOptions.throttledSelectorFrequency, { traceSelectors: this.storeOptions.traceSelectors });
return this.selectorFlushManager;
}
disposeSelectorFlushManager() {
this.selectorFlushManager?.dispose();
this.selectorFlushManager = void 0;
}
getReducers() {
return { ...this.reducers };
}
get state() {
if (!this.storeContext) throw new Error("Cannot access Store.state before Store.init() has been called.");
return this.storeContext.store.getState();
}
get dispatch() {
if (!this.storeContext) throw new Error("Cannot access Store.dispatch before Store.init() has been called.");
return this.storeContext.store.dispatch;
}
/**
* Return an existing store context that should prevent re-initialization.
* Defaults to the instance-level context (guards against double init());
* framework-specific subclasses can override to consult external contexts.
*/
getExistingStoreContext() {
return this.storeContext;
}
initStoreContext(initialState) {
if (this.getExistingStoreContext()) return;
const middlewares = this.getMiddlewarePipeline();
const storeContext = { store: legacy_createStore(combineReducers(this.reducers), this.createExtendedDefaultState(initialState), applyMiddleware(...middlewares)) };
this.storeContext = storeContext;
return storeContext;
}
getSelectorFlushManager() {
return this.getOrCreateSelectorFlushManager();
}
getSelectorTraceReporter() {
return (trace) => this.reportSelectorTrace(trace);
}
reportSelectorTrace(trace) {
if (!this.selectorTracingEnabled) return;
if (this.maxLoggedSelectorAccessedPathCount !== void 0 && trace.accessedPathCount <= this.maxLoggedSelectorAccessedPathCount) return;
this.maxLoggedSelectorAccessedPathCount = trace.accessedPathCount;
const accessedPaths = renderAccessedPaths(trace.accessedPaths, trace.parsedPaths);
console.info("[ag-redux-toolkit] selector trace", {
accessedPathCount: trace.accessedPathCount,
accessedPaths,
selectorSource: getSelectorSourceSnippet(trace.selectorFunc)
});
}
traceSelectors() {
this.selectorTracingEnabled = true;
}
startSagaManager(storeContext) {
this.runSagaSafely(sagaManager, storeContext.store, (runningTasksContext) => {
storeContext.tasks = runningTasksContext;
});
}
initDevTool() {
if (!this.storeContext) throw new Error("Cannot initialize Store.initDevTool before Store.init() has been called.");
this.disposeDevTools = registerGlobalDevTools(this);
return this.disposeDevTools;
}
dispose() {
if (!this.storeContext) {
this.disposeSelectorFlushManager();
return;
}
this.disposeDevTools?.();
this.disposeDevTools = void 0;
this.stopSagas();
this.storeContext = void 0;
this.disposeSelectorFlushManager();
}
runSaga(saga) {
const sagaName = deriveSagaName(saga);
if (!this.storeContext) throw new Error(`Cannot run saga "${sagaName}" before Store.init() has been called.`);
if (sagaName === "@internal_sagaManager") throw new Error(`Saga "${INTERNAL_SAGA_MANAGER_NAME}" is reserved for internal saga management and cannot be run directly.`);
const { store } = this.storeContext;
store.dispatch(startSaga(sagaName, saga));
return () => {
store.dispatch(stopSaga(sagaName));
};
}
};
//#endregion
export { StoreRuntime };
//# sourceMappingURL=store-runtime.js.map