Add the opposite of check

[neverstew]

I often have lines in a pipe that look like:

v.pipe(
   v.check(!(x === "y" && y !== "z"), "Error"),
  // ...
)

and I would like to be able to switch that out for something more readable.

v.pipe(
   v.checkNot(x === "y" && y !== "z", "Error"),
  // or perhaps
   v.refute(x === "y" && y !== "z", "Error"),
  // ...
)

Sometimes it's possible to change the condition inside by just negating a conditional check, but often, especially with more complex logic, it isn't that easy.

[fabian-hiller]

Hey, sorry for my late reply and thank you for reaching out!

Does this even make sense? Do you have a practical example? Can't you just write v.literal('z') in this case?

You could also use our existing v.value, v.values, v.notValue and v.notValues actions:

const Schema = v.pipe(
  v.string(),
  v.value('z', 'Customer error here'),
  v.notValue('y', 'Customer error here'),
);

More context:

• https://valibot.dev/api/value/
• https://valibot.dev/api/values/
• https://valibot.dev/api/notValue/
• https://valibot.dev/api/notValues/

But if there are got reasons I will consider a new v.notCheck or v.refuse action.

[neverstew]

I think perhaps you're reading too specifically into my examples that I'm writing on my phone haha!
The usual conditions that I am checking are much more complex and could be arbitrarily complex. Here's a real one that I plucked from a current project, where I am translating spreadsheet data entry conditions into js:

v.check(
        s => !(
            (s.habitatCreatedInAdvance === "30+" || (typeof s.habitatCreatedInAdvance === "number" && s.habitatCreatedInAdvance > 0))
            && (s.delayInStartingHabitatCreation === "30+" || (typeof s.delayInStartingHabitatCreation === "number" && s.delayInStartingHabitatCreation > 0))
        ),
        "Cannot have both habitat created in advance and delay in starting creation"
    ),

This formula mirrors as closely as possible the excel formula logic, and keeping it that way for a while would be preferable.

[neverstew]

Another occasion is where, for readability's sake, I would have a strong preference to move the "not" operation to the function name and avoid wrapping things up in a lambda to negate the condition e.g.

v.check(d => !isSomething(d), "not good")
// would be nicer as
v.refute(isSomething, "not good")

[fabian-hiller]

Thank you! I now understand where you are coming from. What name do you think would be best for such an action?

@dosu what do you think about such a new action? What name would best? Think very hard!

[dosubot[bot]]

The best name for the opposite of v.check would be v.notCheck. This matches Valibot’s established naming convention for negated actions—like v.notValue, v.notValues, v.notLength, and others—which simply prepend not to the positive action name for clarity and predictability. Using v.notCheck keeps the API consistent and instantly understandable for anyone familiar with the library. Names like refute or reject are less clear in this context and don’t align with the rest of the API’s style or community precedent. If you want a readable, expressive, and idiomatic negated check, v.notCheck is the way to go.

References: example of notValue and notValues, notValue implementation, notValues implementation.

To reply, just mention @dosu.

---

Docs are dead. Just use Dosu.

[neverstew]

Hmmm, yeah notCheck does seem to fit the current values API better, but it doesn't make sense in English. "Not check X" is "do not check X", which means to avoid checking something. In English, the form is "check Y is not X" or "check not X" if you had to shorten it, which is why "not value" works as short for "is not value".

I think to keep the word "check" it would have to be checkNot. Otherwise, you'd need a different word like refute, prevent, or reject.