@angular-architects/ngrx-toolkit 0.1.0 → 0.1.2

package/fesm2022/angular-architects-ngrx-toolkit.mjs

@@ -0,0 +1,653 @@
+import { patchState as patchState$1, signalStoreFeature, withState, withComputed, withMethods, withHooks, getState } from '@ngrx/signals';
+import * as i0 from '@angular/core';
+import { signal, effect, inject, PLATFORM_ID, computed, isSignal, untracked, Injectable, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, Injector } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { Subject, pipe, tap, map } from 'rxjs';
+import { setAllEntities, addEntity, updateEntity, removeEntity } from '@ngrx/signals/entities';
+import { rxMethod } from '@ngrx/signals/rxjs-interop';
+
+const storeRegistry = signal({});
+let currentActionNames = new Set();
+let synchronizationInitialized = false;
+function initSynchronization() {
+    effect(() => {
+        if (!connection) {
+            return;
+        }
+        const stores = storeRegistry();
+        const rootState = {};
+        for (const name in stores) {
+            const store = stores[name];
+            rootState[name] = store();
+        }
+        const names = Array.from(currentActionNames);
+        const type = names.length ? names.join(', ') : 'Store Update';
+        currentActionNames = new Set();
+        connection.send({ type }, rootState);
+    });
+}
+function getValueFromSymbol(obj, symbol) {
+    if (typeof obj === 'object' && obj && symbol in obj) {
+        return obj[symbol];
+    }
+}
+function getStoreSignal(store) {
+    const [signalStateKey] = Object.getOwnPropertySymbols(store);
+    if (!signalStateKey) {
+        throw new Error('Cannot find State Signal');
+    }
+    return getValueFromSymbol(store, signalStateKey);
+}
+let connection;
+/**
+ * required for testing. is not exported during build
+ */
+function reset() {
+    connection = undefined;
+    synchronizationInitialized = false;
+    storeRegistry.set({});
+}
+/**
+ * @param name store's name as it should appear in the DevTools
+ */
+function withDevtools(name) {
+    return (store) => {
+        const isServer = isPlatformServer(inject(PLATFORM_ID));
+        if (isServer) {
+            return store;
+        }
+        const extensions = window.__REDUX_DEVTOOLS_EXTENSION__;
+        if (!extensions) {
+            return store;
+        }
+        if (!connection) {
+            connection = extensions.connect({
+                name: 'NgRx Signal Store',
+            });
+        }
+        const storeSignal = getStoreSignal(store);
+        storeRegistry.update((value) => ({
+            ...value,
+            [name]: storeSignal,
+        }));
+        if (!synchronizationInitialized) {
+            initSynchronization();
+            synchronizationInitialized = true;
+        }
+        return store;
+    };
+}
+const patchState = (state, action, ...rest) => {
+    currentActionNames.add(action);
+    return patchState$1(state, ...rest);
+};
+
+function assertActionFnSpecs(obj) {
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('%o is not an Action Specification');
+    }
+}
+
+function payload() {
+    return {};
+}
+const noPayload = {};
+function createActionFns(actionFnSpecs, reducerRegistry, effectsRegistry, state) {
+    const actionFns = {};
+    for (const type in actionFnSpecs) {
+        const actionFn = (payload) => {
+            const fullPayload = { ...payload, type };
+            const reducer = reducerRegistry[type];
+            if (reducer) {
+                reducer(state, fullPayload);
+            }
+            const effectSubject = effectsRegistry[type];
+            if (effectSubject) {
+                effectSubject.next(fullPayload);
+            }
+            return fullPayload;
+        };
+        actionFn.type = type.toString();
+        actionFns[type] = actionFn;
+    }
+    return actionFns;
+}
+function createPublicAndAllActionsFns(actionFnSpecs, reducerRegistry, effectsRegistry, state) {
+    if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {
+        const privates = actionFnSpecs['private'] || {};
+        const publics = actionFnSpecs['public'] || {};
+        assertActionFnSpecs(privates);
+        assertActionFnSpecs(publics);
+        const privateActionFns = createActionFns(privates, reducerRegistry, effectsRegistry, state);
+        const publicActionFns = createActionFns(publics, reducerRegistry, effectsRegistry, state);
+        return {
+            all: { ...privateActionFns, ...publicActionFns },
+            publics: publicActionFns,
+        };
+    }
+    const actionFns = createActionFns(actionFnSpecs, reducerRegistry, effectsRegistry, state);
+    return { all: actionFns, publics: actionFns };
+}
+function fillReducerRegistry(reducer, actionFns, reducerRegistry) {
+    function on(action, reducerFn) {
+        reducerRegistry[action.type] = reducerFn;
+    }
+    reducer(actionFns, on);
+    return reducerRegistry;
+}
+function fillEffects(effects, actionFns, effectsRegistry = {}) {
+    function create(action) {
+        const subject = new Subject();
+        effectsRegistry[action.type] = subject;
+        return subject.asObservable();
+    }
+    const effectObservables = effects(actionFns, create);
+    return Object.values(effectObservables);
+}
+function startSubscriptions(observables) {
+    return observables.map((observable) => observable.subscribe());
+}
+function processRedux(actionFnSpecs, reducer, effects, store) {
+    const reducerRegistry = {};
+    const effectsRegistry = {};
+    const actionsMap = createPublicAndAllActionsFns(actionFnSpecs, reducerRegistry, effectsRegistry, store);
+    const actionFns = actionsMap.all;
+    const publicActionsFns = actionsMap.publics;
+    fillReducerRegistry(reducer, actionFns, reducerRegistry);
+    const effectObservables = fillEffects(effects, actionFns, effectsRegistry);
+    const subscriptions = startSubscriptions(effectObservables);
+    return {
+        methods: publicActionsFns,
+        subscriptions: subscriptions,
+    };
+}
+/**
+ * @param redux redux
+ *
+ * properties do not start with `with` since they are not extension functions on their own.
+ *
+ * no dependency to NgRx
+ *
+ * actions are passed to reducer and effects, but it is also possible to use other actions.
+ * effects provide forAction and do not return anything. that is important because effects should stay inaccessible
+ */
+function withRedux(redux) {
+    return (store) => {
+        const { methods, subscriptions } = processRedux(redux.actions, redux.reducer, redux.effects, store);
+        return {
+            ...store,
+            methods,
+        };
+    };
+}
+
+function getCallStateKeys(config) {
+    const prop = config?.collection;
+    return {
+        callStateKey: prop ? `${config.collection}CallState` : 'callState',
+        loadingKey: prop ? `${config.collection}Loading` : 'loading',
+        loadedKey: prop ? `${config.collection}Loaded` : 'loaded',
+        errorKey: prop ? `${config.collection}Error` : 'error',
+    };
+}
+function withCallState(config) {
+    const { callStateKey, errorKey, loadedKey, loadingKey } = getCallStateKeys(config);
+    return signalStoreFeature(withState({ [callStateKey]: 'init' }), withComputed((state) => {
+        const callState = state[callStateKey];
+        return {
+            [loadingKey]: computed(() => callState() === 'loading'),
+            [loadedKey]: computed(() => callState() === 'loaded'),
+            [errorKey]: computed(() => {
+                const v = callState();
+                return typeof v === 'object' ? v.error : null;
+            })
+        };
+    }));
+}
+function setLoading(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loading' };
+    }
+    return { callState: 'loading' };
+}
+function setLoaded(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loaded' };
+    }
+    else {
+        return { callState: 'loaded' };
+    }
+}
+function setError(error, prop) {
+    let errorMessage = '';
+    if (!error) {
+        errorMessage = '';
+    }
+    else if (typeof error === 'object' && 'message' in error) {
+        errorMessage = String(error.message);
+    }
+    else {
+        errorMessage = String(error);
+    }
+    if (prop) {
+        return { [`${prop}CallState`]: { error: errorMessage } };
+    }
+    else {
+        return { callState: { error: errorMessage } };
+    }
+}
+
+function capitalize$1(str) {
+    return str ? str[0].toUpperCase() + str.substring(1) : str;
+}
+function getDataServiceKeys(options) {
+    const filterKey = options.collection ? `${options.collection}Filter` : 'filter';
+    const selectedIdsKey = options.collection ? `selected${capitalize$1(options.collection)}Ids` : 'selectedIds';
+    const selectedEntitiesKey = options.collection ? `selected${capitalize$1(options.collection)}Entities` : 'selectedEntities';
+    const updateFilterKey = options.collection ? `update${capitalize$1(options.collection)}Filter` : 'updateFilter';
+    const updateSelectedKey = options.collection ? `updateSelected${capitalize$1(options.collection)}Entities` : 'updateSelected';
+    const loadKey = options.collection ? `load${capitalize$1(options.collection)}Entities` : 'load';
+    const currentKey = options.collection ? `current${capitalize$1(options.collection)}` : 'current';
+    const loadByIdKey = options.collection ? `load${capitalize$1(options.collection)}ById` : 'loadById';
+    const setCurrentKey = options.collection ? `setCurrent${capitalize$1(options.collection)}` : 'setCurrent';
+    const createKey = options.collection ? `create${capitalize$1(options.collection)}` : 'create';
+    const updateKey = options.collection ? `update${capitalize$1(options.collection)}` : 'update';
+    const updateAllKey = options.collection ? `updateAll${capitalize$1(options.collection)}` : 'updateAll';
+    const deleteKey = options.collection ? `delete${capitalize$1(options.collection)}` : 'delete';
+    // TODO: Take these from @ngrx/signals/entities, when they are exported
+    const entitiesKey = options.collection ? `${options.collection}Entities` : 'entities';
+    const entityMapKey = options.collection ? `${options.collection}EntityMap` : 'entityMap';
+    const idsKey = options.collection ? `${options.collection}Ids` : 'ids';
+    return {
+        filterKey,
+        selectedIdsKey,
+        selectedEntitiesKey,
+        updateFilterKey,
+        updateSelectedKey,
+        loadKey,
+        entitiesKey,
+        entityMapKey,
+        idsKey,
+        currentKey,
+        loadByIdKey,
+        setCurrentKey,
+        createKey,
+        updateKey,
+        updateAllKey,
+        deleteKey
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function withDataService(options) {
+    const { dataServiceType, filter, collection: prefix } = options;
+    const { entitiesKey, filterKey, loadKey, selectedEntitiesKey, selectedIdsKey, updateFilterKey, updateSelectedKey, currentKey, createKey, updateKey, updateAllKey, deleteKey, loadByIdKey, setCurrentKey } = getDataServiceKeys(options);
+    const { callStateKey } = getCallStateKeys({ collection: prefix });
+    return signalStoreFeature(withState(() => ({
+        [filterKey]: filter,
+        [selectedIdsKey]: {},
+        [currentKey]: undefined
+    })), withComputed((store) => {
+        const entities = store[entitiesKey];
+        const selectedIds = store[selectedIdsKey];
+        return {
+            [selectedEntitiesKey]: computed(() => entities().filter(e => selectedIds()[e.id]))
+        };
+    }), withMethods((store) => {
+        const dataService = inject(dataServiceType);
+        return {
+            [updateFilterKey]: (filter) => {
+                patchState$1(store, { [filterKey]: filter });
+            },
+            [updateSelectedKey]: (id, selected) => {
+                patchState$1(store, (state) => ({
+                    [selectedIdsKey]: {
+                        ...state[selectedIdsKey],
+                        [id]: selected,
+                    }
+                }));
+            },
+            [loadKey]: async () => {
+                const filter = store[filterKey];
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const result = await dataService.load(filter());
+                    patchState$1(store, prefix ? setAllEntities(result, { collection: prefix }) : setAllEntities(result));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [loadByIdKey]: async (id) => {
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const current = await dataService.loadById(id);
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                    patchState$1(store, { [currentKey]: current });
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [setCurrentKey]: (current) => {
+                patchState$1(store, { [currentKey]: current });
+            },
+            [createKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const created = await dataService.create(entity);
+                    patchState$1(store, { [currentKey]: created });
+                    patchState$1(store, prefix ? addEntity(created, { collection: prefix }) : addEntity(created));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [updateKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const updated = await dataService.update(entity);
+                    patchState$1(store, { [currentKey]: updated });
+                    // Why do we need this cast to Partial<Entity>?
+                    const updateArg = { id: updated.id, changes: updated };
+                    patchState$1(store, prefix ? updateEntity(updateArg, { collection: prefix }) : updateEntity(updateArg));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [updateAllKey]: async (entities) => {
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    const result = await dataService.updateAll(entities);
+                    patchState$1(store, prefix ? setAllEntities(result, { collection: prefix }) : setAllEntities(result));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [deleteKey]: async (entity) => {
+                patchState$1(store, { [currentKey]: entity });
+                store[callStateKey] && patchState$1(store, setLoading(prefix));
+                try {
+                    await dataService.delete(entity);
+                    patchState$1(store, { [currentKey]: undefined });
+                    patchState$1(store, prefix ? removeEntity(entity.id, { collection: prefix }) : removeEntity(entity.id));
+                    store[callStateKey] && patchState$1(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState$1(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+        };
+    }));
+}
+
+const defaultOptions = {
+    maxStackSize: 100
+};
+function getUndoRedoKeys(collections) {
+    if (collections) {
+        return collections.flatMap(c => [`${c}EntityMap`, `${c}Ids`, `selected${capitalize$1(c)}Ids`, `${c}Filter`]);
+    }
+    return ['entityMap', 'ids', 'selectedIds', 'filter'];
+}
+function withUndoRedo(options = {}) {
+    let previous = null;
+    let skipOnce = false;
+    const normalized = {
+        ...defaultOptions,
+        ...options
+    };
+    //
+    // Design Decision: This feature has its own
+    // internal state.
+    //
+    const undoStack = [];
+    const redoStack = [];
+    const canUndo = signal(false);
+    const canRedo = signal(false);
+    const updateInternal = () => {
+        canUndo.set(undoStack.length !== 0);
+        canRedo.set(redoStack.length !== 0);
+    };
+    const keys = getUndoRedoKeys(normalized?.collections);
+    return signalStoreFeature(withComputed(() => ({
+        canUndo: canUndo.asReadonly(),
+        canRedo: canRedo.asReadonly()
+    })), withMethods((store) => ({
+        undo() {
+            const item = undoStack.pop();
+            if (item && previous) {
+                redoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                previous = item;
+            }
+            updateInternal();
+        },
+        redo() {
+            const item = redoStack.pop();
+            if (item && previous) {
+                undoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState$1(store, item);
+                previous = item;
+            }
+            updateInternal();
+        }
+    })), withHooks({
+        onInit(store) {
+            effect(() => {
+                const cand = keys.reduce((acc, key) => {
+                    const s = store[key];
+                    if (s && isSignal(s)) {
+                        return {
+                            ...acc,
+                            [key]: s()
+                        };
+                    }
+                    return acc;
+                }, {});
+                if (skipOnce) {
+                    skipOnce = false;
+                    return;
+                }
+                // Clear redoStack after recorded action
+                redoStack.splice(0);
+                if (previous) {
+                    undoStack.push(previous);
+                }
+                if (redoStack.length > normalized.maxStackSize) {
+                    undoStack.unshift();
+                }
+                previous = cand;
+                // Don't propogate current reactive context
+                untracked(() => updateInternal());
+            });
+        }
+    }));
+}
+
+const NOOP = () => { };
+const StorageSyncStub = {
+    clearStorage: NOOP,
+    readFromStorage: NOOP,
+    writeToStorage: NOOP,
+};
+function withStorageSync(configOrKey) {
+    const { key, autoSync = true, select = (state) => state, parse = JSON.parse, stringify = JSON.stringify, storage: storageFactory = () => localStorage, } = typeof configOrKey === 'string' ? { key: configOrKey } : configOrKey;
+    return signalStoreFeature(withMethods((store, platformId = inject(PLATFORM_ID)) => {
+        if (isPlatformServer(platformId)) {
+            console.warn(`'withStorageSync' provides non-functional implementation due to server-side execution`);
+            return StorageSyncStub;
+        }
+        const storage = storageFactory();
+        return {
+            /**
+             * Removes the item stored in storage.
+             */
+            clearStorage() {
+                storage.removeItem(key);
+            },
+            /**
+             * Reads item from storage and patches the state.
+             */
+            readFromStorage() {
+                const stateString = storage.getItem(key);
+                if (stateString) {
+                    patchState$1(store, parse(stateString));
+                }
+            },
+            /**
+             * Writes selected portion to storage.
+             */
+            writeToStorage() {
+                const slicedState = select(getState(store));
+                storage.setItem(key, stringify(slicedState));
+            },
+        };
+    }), withHooks({
+        onInit(store, platformId = inject(PLATFORM_ID)) {
+            if (isPlatformServer(platformId)) {
+                return;
+            }
+            if (autoSync) {
+                store.readFromStorage();
+                effect(() => {
+                    store.writeToStorage();
+                });
+            }
+        },
+    }));
+}
+
+function isUnsubscribable(fn) {
+    return !!fn?.unsubscribe;
+}
+function capitalize(str) {
+    return str ? str[0].toUpperCase() + str.substring(1) : str;
+}
+function isActionCreator(action) {
+    return (typeof action === 'function' &&
+        action &&
+        action.type &&
+        typeof action.type === 'string');
+}
+
+class SignalReduxStore {
+    constructor() {
+        this.mapperDict = {};
+        this.dispatch = rxMethod(pipe(tap((action) => {
+            const callbacks = this.mapperDict[action.type];
+            if (callbacks?.storeMethod) {
+                if (isUnsubscribable(callbacks.storeMethod) &&
+                    callbacks.resultMethod) {
+                    return callbacks.storeMethod(action, (a) => {
+                        const resultAction = callbacks.resultMethod?.(a);
+                        this.dispatch(resultAction);
+                    });
+                }
+                return callbacks?.storeMethod(action);
+            }
+            return;
+        })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    connectFeatureStore(mappers) {
+        mappers.forEach(mapper => mapper.types.forEach(action => this.mapperDict[action] = {
+            storeMethod: mapper.storeMethod,
+            resultMethod: mapper.resultMethod
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SignalReduxStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SignalReduxStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SignalReduxStore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+function injectReduxDispatch() {
+    return inject(SignalReduxStore).dispatch;
+}
+
+function mapAction(...args) {
+    let resultMethod = args.pop();
+    let storeMethod = args.pop();
+    if (isActionCreator(storeMethod)) {
+        args.push(storeMethod);
+        storeMethod = resultMethod || storeMethod;
+        resultMethod = undefined;
+    }
+    const types = args.map((creator) => creator.type);
+    return {
+        types,
+        storeMethod,
+        resultMethod
+    };
+}
+function withActionMappers(...mappers) {
+    return mappers;
+}
+function createReduxState(storeName, signalStore, withActionMappers) {
+    const isRootProvider = signalStore?.ɵprov?.providedIn === 'root';
+    return {
+        [`provide${capitalize(storeName)}Store`]: (connectReduxDevtools = false) => makeEnvironmentProviders([
+            isRootProvider ? [] : signalStore,
+            {
+                provide: ENVIRONMENT_INITIALIZER,
+                multi: true,
+                useFactory: (signalReduxStore = inject(SignalReduxStore), store = inject(signalStore)) => () => {
+                    if (connectReduxDevtools) {
+                        // addStoreToReduxDevtools(store, storeName, false);
+                    }
+                    signalReduxStore.connectFeatureStore(withActionMappers(store));
+                }
+            }
+        ]),
+        [`inject${capitalize(storeName)}Store`]: () => Object.assign(inject(signalStore), { dispatch: injectReduxDispatch() })
+    };
+}
+
+function reduxMethod(generator, resultMethodOrConfig, config) {
+    const injector = inject(Injector);
+    if (typeof resultMethodOrConfig === 'function') {
+        let unsubscribable;
+        const inputResultFn = ((input, resultMethod = resultMethodOrConfig) => {
+            const rxMethodWithResult = rxMethod(pipe(generator, map(resultMethod)), {
+                ...(config || {}),
+                injector: config?.injector || injector
+            });
+            const rxWithInput = rxMethodWithResult(input);
+            unsubscribable = { unsubscribe: rxWithInput.unsubscribe.bind(rxWithInput) };
+            return rxWithInput;
+        });
+        inputResultFn.unsubscribe = () => unsubscribable?.unsubscribe();
+        return inputResultFn;
+    }
+    return rxMethod(generator, resultMethodOrConfig);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { capitalize$1 as capitalize, createReduxState, getCallStateKeys, getDataServiceKeys, getUndoRedoKeys, mapAction, noPayload, patchState, payload, reduxMethod, setError, setLoaded, setLoading, withActionMappers, withCallState, withDataService, withDevtools, withRedux, withStorageSync, withUndoRedo };
+//# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map