Inverting steps in prosemirror-changeset

1

I’m reimplementing the track example to be more granular, so that individual changes can be reverted or accepted.

prosemirror-changeset seems like a wonderful utility for this, although I’m having trouble understanding the inserted and deleted API and how that interacts with the data field.

My approach currently is to invert the steps and pass their global index as data

init(config, state) {
  return {
    maps: [],
    steps: [],
    changeSet: ChangeSet.create(state.doc),
  }
},
apply(tr, state) {
  if (!tr.docChanged) return state
  return {
    maps: state.maps.concat(tr.mapping.maps),
    steps: state.steps.concat(tr.steps),
    changeSet: changeSet.addSteps(tr.doc, tr.mapping.maps, tr.steps.map((step, i) => prevState.steps.length + i))
  }
}

My confusion is with implementing revert: a change can have both inserted and deleted arrays:

And when using that with simplifyChanges, inserted and deleted arrays don’t have to have the same length.

Is there a way to access data for a change like change.data, instead of indirectly through change.inserted[i].data or change.deleted[i].data?

2

A change can both delete content and insert content. Both of those may have data associated with them, and a given changed range may have different pieces with different data values in it. Could you say a bit more about why this is confusing?

3

I’d want a way to associate a change 1:1 with a step, instead of associating data with insertions and deletions.

The insertions and deletions data is useful for decorations, but for a reverting, I just need to revert the entire change atomically.

4

That’s not the kind of thing prosemirror-changeset can help you with. That converts from steps to changed ranges. It sounds like you want to store the actual steps instead.

5

I am storing the steps, but wondering if there’s a better way of associating changes with a series of steps, and then accessing those series of steps so I can either “revert” the change by applying inverted steps, or “accept” the change by removing step from the changeset.

My current approach is to keep the steps separately, but store the index of the steps:

changeSet.addSteps(
  tr.doc, 
  tr.mapping.maps, 
  tr.steps.map((step, i) => ({ index: prevState.steps.length + i })
))

export function acceptChange(change: Change): Command {
  return function (state, dispatch) {
    const tr = state.tr;
    const diffState = diffPluginKey.getState(state);
    if (!diffState) return false;
    const changeSet = diffState.changeSet as ChangeSet;
    const updated = changeSet.changes.filter(c => c !== change);
    // No API to removeSteps so we re-create with filtered changes.
    tr.setMeta(diffPluginKey, new ChangeSet(changeSet.config, updated));
    if (dispatch) dispatch(tr);
    return true;
  }
}

export function revertChange(change: Change): Command {
  return function (state, dispatch) {
    // De-duplicate indices as data can appear twice in deleted and inserted
    const stepIds: number[] = Array.from(new Set(
      change.inserted.map(span => span.data.index).concat(change.deleted.map(span => span.data.index))
    ))

    const diffState = diffPluginKey.getState(state);
    if (!diffState) return false;

    const remap = new Mapping(diffState.maps)
    const tr = state.tr;

    // From tracking example:
    // Build up a transaction that includes all (inverted) steps in this
    // commit, rebased to the current document. They have to be applied
    // in reverse order.
    for (let i = stepIds.length - 1; i >= 0; i--) {
      const index = stepIds[i];
      const step = diffState.steps[index].map(remap.slice(index + 1))
      if (!step) continue;
      tr.step(step);
    }
    if (!tr.docChanged) return false;
    if (dispatch) dispatch(tr);
    return true;
  }
}