Shouldn't Atlassian's prosemirror-utils be a dependency ?

[jclaveau]

Hello folks !

I just realized that the content of https://github.com/Milkdown/milkdown/tree/main/packages/prose/src/toolkit/prose is more or less a copy of https://github.com/atlassian/prosemirror-utils/tree/master/src which is hard to understand due to several caveats:

• if I import prosemirror-utils it will cost some extra space for nothing as non factorizable code for the same logic
• other tools of prosemirror-utils / updates are not made available (the workaround is the point above)
• Much more important, prosemirror-utils is not licensed under MIT but under Apache 2 license which is a little more restrictive and, if I understand well, this is a real issue for Milkdown and its users
• Atlassian's version is fully tested (94%) and documented

For what I see, the main difference between in Milkdown's implementation is adding a higher order function to split the parameters in two calls as:

// Atlassian version
// Iterates over parent nodes starting from the given `$pos`, returning the closest node and its start position `predicate` returns truthy for. `start` points to the start position of the node, `pos` points directly before the node.
//
// ```javascript
// const predicate = node => node.type === schema.nodes.blockquote;
// const parent = findParentNodeClosestToPos(state.doc.resolve(5), predicate);
// ```
export const findParentNodeClosestToPos = (
  $pos: ResolvedPos,
  predicate: FindPredicate
): FindResult => {
  for (let i = $pos.depth; i > 0; i--) {
    const node = $pos.node(i);
    if (predicate(node)) {
      return {
        pos: i > 0 ? $pos.before(i) : 0,
        start: $pos.start(i),
        depth: i,
        node,
      };
    }
  }
};

// Milkdown version
export function findParentNodeClosestToPos(predicate: Predicate) {
  return ($pos: ResolvedPos): ContentNodeWithPos | undefined => {
    for (let i = $pos.depth; i > 0; i--) {
      const node = $pos.node(i)
      if (predicate(node)) {
        return {
          pos: i > 0 ? $pos.before(i) : 0,
          start: $pos.start(i),
          depth: i,
          node,
        }
      }
    }

    return undefined
  }
}

Which, IMHO, only adds a layer of complexity / slow down during the DX for no technical gain.

So my question is: Am I wrong or are these caveats real and, if yes, why so much effort considering them?

Thanks in advance !

[Saul-Mirone]

At first this project use prosemirror-utils as a dependency. But at some time point, it's not possible to use prosemirror-utils because they deleted some methods I relied on (like all the methods about table). I don't like this feeling that they can just delete a whole folder someday for no reason. And they don't have any updates for 2 years. So I re implemented the APIs with my own tastes. And I don't think this will actually bother someone because of the license type, because it's a none commercial project.

[jclaveau]

They deleted methods without major version change? Oh lord, I get your point!

And considering this high-order double function call pattern, what do you attempt exactly by using it (it's the first time I see it)?
It seems to be dedicated to making groups of parameters but you don't use it here for example, is there some specific places you use it and some not?

Thank you for your fast answer btw !