🚀[FEATURE]: updateEachItem, removeEachItem operators

[kulichkoff]

Relevant Package

This feature request is for @ngxs/operators

Description

Implement very useful state operators (updateEachItem and removeEachItem) that must change array-like state, taking selector and operatorOrValue arguments.

Describe the problem you are trying to solve

It was unexpected for me that current updateItem and removeItem implementations on selectors change only one state item. I think, updateEach is very useful and I needed to use something like that.

Describe the solution you'd like

I already implemented those operators in my project. I can contribute by myself or you can just take my solution:

export function updateEachItem<T>(
  selector: NoInfer<Predicate<T>>,
  operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>
): StateOperator<T[]> {
  return (existing: readonly T[]) => {
    return existing.map((item: T) => {
      if (!selector(item)) {
        return item;
      }

      let value: T = null!;
      const theOperatorOrValue = operatorOrValue as T | StateOperator<T>;
      if (isStateOperator(theOperatorOrValue)) {
        value = theOperatorOrValue(item as ExistingState<T>);
      } else {
        value = theOperatorOrValue;
      }
      return value;
    });
  };
}

export function removeEachItem<T>(
  selector: NoInfer<Predicate<T>>
): StateOperator<T[]> {
  return (existing: readonly T[]) => {
    return existing.filter((item: T) => !selector(item));
  }
}

Describe alternatives you've considered

None.

[gurubase]

🚀[FEATURE]: updateEachItem, removeEachItem operators

Relevant Package

This feature request is for @ngxs/operators

Description

Implement very useful state operators (updateEachItem and removeEachItem) that must change array-like state, taking selector and operatorOrValue arguments.

Describe the problem you are trying to solve

It was unexpected for me that current updateItem and removeItem implementations on selectors change only one state item. I think, updateEach is very useful and I needed to use something like that.

Describe the solution you'd like

I already implemented those operators in my project. I can contribute by myself or you can just take my solution:

export function updateEachItem<T>(
  selector: NoInfer<Predicate<T>>,
  operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>
): StateOperator<T[]> {
  return (existing: readonly T[]) => {
    return existing.map((item: T) => {
      if (!selector(item)) {
        return item;
      }

      let value: T = null!;
      const theOperatorOrValue = operatorOrValue as T | StateOperator<T>;
      if (isStateOperator(theOperatorOrValue)) {
        value = theOperatorOrValue(item as ExistingState<T>);
      } else {
        value = theOperatorOrValue;
      }
      return value;
    });
  };
}

export function removeEachItem<T>(
  selector: NoInfer<Predicate<T>>
): StateOperator<T[]> {
  return (existing: readonly T[]) => {
    return existing.filter((item: T) => !selector(item));
  }
}

Describe alternatives you've considered

None.

Hey @kulichkoff

Here is my answer:

This feature request is for @ngxs/operators.

Description

The request is to implement updateEachItem and removeEachItem operators to modify array-like states. These operators should take a selector and operatorOrValue as arguments.

Problem

The current updateItem and removeItem operators only modify a single item in the state. The proposed operators would allow for more comprehensive updates by applying changes to all items that match the selector.

Proposed Solution

The user has provided implementations for these operators:

export function updateEachItem<T>(
  selector: NoInfer<Predicate<T>>,
  operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>
): StateOperator<T[]> {
  return (existing: readonly T[]) => {
    return existing.map((item: T) => {
      if (!selector(item)) {
        return item;
      }

      let value: T = null!;
      const theOperatorOrValue = operatorOrValue as T | StateOperator<T>;
      if (isStateOperator(theOperatorOrValue)) {
        value = theOperatorOrValue(item as ExistingState<T>);
      } else {
        value = theOperatorOrValue;
      }
      return value;
    });
  };
}

export function removeEachItem<T>(
  selector: NoInfer<Predicate<T>>
): StateOperator<T[]> {
  return (existing: readonly T[]) => {
    return existing.filter((item: T) => !selector(item));
  }
}

Alternatives

None considered.

These operators would enhance the ability to perform batch updates or removals in state management, making them a valuable addition to the NGXS operators.

---

Trust Score: 🟡 55%

Sources:

• State Operators | NGXS
• Custom State Operators | NGXS
• update-item.ts
• remove-item.ts

👀 View on Gurubase

Tag @Gurubase to ask me a question.