How to use the ix.Iterable.empty function in ix

.catch(e => {
            this.alertForError(e, 'Data Response Error');

            return this.wx.getObservable>({
              items: Iterable.empty(),
              count: 0,
            });
          });
      })

.merge(
        this.requests.changed
          .map(() => true),
        this.responses.changed
          .map(() => false),
      )
      .toProperty(true);

    const validResponses = this.wx
      .whenAny(this.responses, x => x)
      .filterNull()
      .share();

    this.projectedSource = validResponses
      .map(x => x.items)
      .toProperty(Iterable.empty(), false);

    this.projectedCount = validResponses
      .map(x => x.count)
      .toProperty();

    if (this.pager != null) {
      this.addSubscription(
        this.wx
          .whenAny(
            this.projectedCount,
            x => x,
          )
          .filterNull()
          .invokeCommand(this.pager.updateCount),
      );

import { Iterable } from 'ix';
import { Observable } from 'rxjs';

import { IterableLike, ObservableLike, ReadOnlyProperty, Command } from '../../../WebRx';
import { BaseViewModel } from '../../React';

export class ItemsViewModel extends BaseViewModel {
  public static displayName = 'ItemsViewModel';

  protected readonly emptySource = Iterable.empty();

  public readonly source: ReadOnlyProperty>;
  public readonly count: ReadOnlyProperty;

  constructor(
    source: ObservableLike>,
  ) {
    super();

    this.source = this.wx
      .getObservableOrAlert(
        () => {
          return this.wx
            .getObservable(source)
            .map(x => Iterable.from(x));
        },

export function filterTreeItems(
  items: IterableLike | undefined,
  itemsSource: (item: T) => (IterableLike | undefined),
  itemsAssign: (item: T, items: Iterable) => T,
  filter: (item: T) => boolean,
): Iterable {
  if (items == null) {
    return Iterable.empty();
  }

  return Iterable
    .from(items)
    .map(x => {
      const result = filterTreeItems(itemsSource(x), itemsSource, itemsAssign, filter);

      if (result.some(() => true) || filter(x)) {
        return itemsAssign(x, result);
      }

      return undefined;
    })
    .filterNull();
}

constructor(
    protected readonly responseSelector: (request: DataSourceRequest> | undefined) => ObservableOrValue | undefined>,
    itemsSource: (item: T) => (IterableLike | undefined),
    search?: SearchViewModel | null,
    context?: ObservableLike,
    rateLimit = AsyncDataGridViewModel.DefaultRateLimit,
  ) {
    super(Iterable.empty(), itemsSource, x => x, undefined, search, context, rateLimit);
  }

constructor(
    protected readonly responseSelector: (request: DataSourceRequest | undefined) => ObservableOrValue | undefined>,
    pager?: PagerViewModel,
    context?: ObservableLike,
    rateLimit = AsyncDataGridViewModel.DefaultRateLimit,
  ) {
    super(Iterable.empty(), pager, context, undefined, rateLimit);
  }