@ngxs-labs/entity-state
Version:
<p align="center"> <img src="https://raw.githubusercontent.com/ngxs-labs/emitter/master/docs/assets/logo.png"> </p>
54 lines • 7.31 kB
JavaScript
import { compose, patch } from '@ngxs/store/operators';
import { updateTimestamp } from './timestamp';
/**
* Removes all entities, clears the active entity and updates the `lastUpdated` timestamp.
*/
export function removeAllEntities() {
return (state) => {
return Object.assign(Object.assign({}, state), { entities: {}, ids: [], active: undefined, lastUpdated: Date.now() });
};
}
/**
* Removes the entities specified by the given IDs.
* The active entity will be cleared if included in the given IDs.
* Updates the `lastUpdated` timestamp.
* @param ids IDs to remove
*/
export function removeEntities(ids) {
const entityRemoval = patch({
entities: removeEntitiesFromDictionary(ids),
ids: removeEntitiesFromArray(ids)
});
return compose(entityRemoval, clearActiveIfRemoved(ids), updateTimestamp());
}
/**
* Only clears the `active` entity, if it's included in the given array.
* All other fields will remain untouched in any case.
* @param idsForRemoval the IDs to be removed
*/
export function clearActiveIfRemoved(idsForRemoval) {
return (state) => {
return Object.assign(Object.assign({}, state), { active: idsForRemoval.includes(state.active) ? undefined : state.active });
};
}
/**
* Removes the given items from the existing items, based on equality.
* @param forRemoval items to remove
*/
export function removeEntitiesFromArray(forRemoval) {
return (existing) => {
return existing.filter(value => !forRemoval.includes(value));
};
}
/**
* Removes items from the dictionary, based on the given keys.
* @param keysForRemoval the keys to be removed
*/
export function removeEntitiesFromDictionary(keysForRemoval) {
return (existing) => {
const clone = Object.assign({}, existing);
keysForRemoval.forEach(key => delete clone[key]);
return clone;
};
}
//# sourceMappingURL=data:application/json;base64,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