IntCollection.hx

import tink.pure.*;

using tink.state.Promised;
using tink.CoreApi;

private typedef Payload<Key, Item> = {
  final order:List<Key>;
  final items:Mapping<Key, Item>;
}

class IntCollection<RawData, Item> implements coconut.data.Model {
  @:editable private var revision:Int = 0;
  @:constant var fetch:Void->Promise<List<RawData>>;
  @:constant var createItem:Int->(()->RawData)->Item;
  @:constant var extractKey:RawData->Int;

  @:loaded private var _rawData:Payload<Int, RawData> = {
    revision;
    fetch().next(list -> {
      var order = [],
          items = new Map();
      for (raw in list) {
        var key = extractKey(raw);
        order.push(key);
        items[key] = raw;
      }

      ({ order:order, items: items }:Payload<Int, RawData>);
    });
  }

  @:computed private var _stableRaw:Mapping<Int, RawData> = switch [_rawData, $last] {
    case [Done({ items: v }), _] | [_, Some(v)]: v;
    default: null;
  }

  @:computed var map:Mapping<Int, Item> = {
    var last = switch ($last) {
      case Some(v): v;
      default: null;
    }

    switch _rawData {
      case Done({ items: items }):
        [for (k => v in items) k => switch last[k] {
          case null: createItem(k, () -> _stableRaw[k]);
          case i: i;
        }];
      default: last;
    }
  }

  @:computed var status:Promised<Noise> = _rawData.map(_ -> Noise);
  @:computed var list:List<Item> = switch [_rawData, $last] {
    case [Done({ order: order }), _]:
      [for (k in order) map[k]];
    case [_, Some(v)]: v;
    default: null;
  }

  public function refresh() {
    revision++;
  }
}