Function setIndexDefinition

src/indexes/index.ts:83–217

(
    indexId: Id,
    tableId: Id,
    getSliceIdOrIds?: Id | ((getCell: GetCell, rowId: Id) => Id | Ids),
    getSortKey?: Id | ((getCell: GetCell, rowId: Id) => SortKey),
    sliceIdSorter?: (sliceId1: Id, sliceId2: Id) => number,
    rowIdSorter: (
      sortKey1: SortKey,
      sortKey2: SortKey,
      sliceId: Id,
    ) => number = defaultSorter,
  )

    collHas(getIndex(indexId), sliceId);

  const setIndexDefinition = (
    indexId: Id,
    tableId: Id,
    getSliceIdOrIds?: Id | ((getCell: GetCell, rowId: Id) => Id | Ids),
    getSortKey?: Id | ((getCell: GetCell, rowId: Id) => SortKey),
    sliceIdSorter?: (sliceId1: Id, sliceId2: Id) => number,
    rowIdSorter: (
      sortKey1: SortKey,
      sortKey2: SortKey,
      sliceId: Id,
    ) => number = defaultSorter,
  ): Indexes => {
    const sliceIdArraySorter = isUndefined(sliceIdSorter)
      ? undefined
      : ([id1]: [Id, IdSet], [id2]: [Id, IdSet]): number =>
          (sliceIdSorter as (sliceId1: Id, sliceId2: Id) => number)(id1, id2);

    setDefinitionAndListen(
      indexId,
      tableId,
      (
        change: () => void,
        changedSliceIds: IdMap<[Id | Ids | undefined, Id | Ids | undefined]>,
        changedSortKeys: IdMap<SortKey>,
        sliceIdOrIdsByRowId?: IdMap<Id | Ids>,
        sortKeys?: IdMap<SortKey>,
        force?: boolean,
      ) => {
        let sliceIdsChanged = 0;
        const changedSlices: IdSet = setNew();
        const unsortedSlices: IdSet = setNew();
        const index = getIndex(indexId);
        collForEach(
          changedSliceIds,
          ([oldSliceIdOrIds, newSliceIdOrIds], rowId) => {
            const oldSliceIds = setNew(oldSliceIdOrIds);
            const newSliceIds = setNew(newSliceIdOrIds);
            collForEach(oldSliceIds, (oldSliceId) =>
              collDel(newSliceIds, oldSliceId)
                ? collDel(oldSliceIds, oldSliceId)
                : 0,
            );

            collForEach(oldSliceIds, (oldSliceId) => {
              setAdd(changedSlices, oldSliceId);
              ifNotUndefined(mapGet(index, oldSliceId), (oldSlice) => {
                collDel(oldSlice, rowId);
                if (collIsEmpty(oldSlice)) {
                  mapSet(index, oldSliceId);
                  sliceIdsChanged = 1;
                }
              });
            });

            collForEach(newSliceIds, (newSliceId) => {
              setAdd(changedSlices, newSliceId);
              if (!collHas(index, newSliceId)) {
                mapSet(index, newSliceId, setNew());