Are plugins and transforms mutually exclusive? about hookstate

[avkonst]

They not mutually exclusive. You can use both. I do not have life example, but here is the snippet:

const state = useStateLink({ name: 'Josh' }, link => {
    // enable the plugin
    link.with(Validation)
    // add validation rules
    Validation(link.nested.name).validate(name => name !== "", 'Name should not be empty');

    // transform the result
    return {
         getName: () => l.nested.name.get(),
         setName: (v: string) => l.nested.name.set(v),
         isStateValid: () => Validation(link).valid(),
         isNameValid: () => Validation(link.nested.name).valid(), 
    }
})

// ... use the state now:
return <p>Name: ${state.getName()}. Is name valid?: ${state.isNameValid()}</p>

[avkonst]

Does it answer your question?

[chasm]

Yep, with slight modifications (you must have typed this in a hurry):

const state = useStateLink({ name: 'Josh' }, link => {
    // enable the plugin
    link.with(Validation)

    // add validation rules
    Validation(link.nested.name).validate(name => name !== "", 'Name should not be empty');

    // transform the result
    return {
         getName: () => link.nested.name.get(),
         setName: (v: string) => link.nested.name.set(v),
         isStateValid: () => Validation(link).valid(),
         isNameValid: () => Validation(link.nested.name).valid(), 
    }
})

// ... use the state now:
return <p>Name: {state.getName()}. Is name valid?: {state.isNameValid()}</p>

Thanks! Works well.

[avkonst]

You can also invoke Validation(link.nested.name).validate(name => name !== "", 'Name should not be empty'); by a trigger from a user, but not when transform is called. For example:

    return {
         getName: () => link.nested.name.get(),
         setName: (v: string) => link.nested.name.set(v),
         validateName: (minLength: number) => Validation(link.nested.name).validate(name => name.length >= minLength, 'Name should not be short');
         isStateValid: () => Validation(link).valid(),
         isNameValid: () => Validation(link.nested.name).valid(), 
    }

and use validateName(...) before render return.

[avkonst]

PS: If you like it, please, consider to spread few words about the library to help the project to grow. And hello from New Zealand. I am from NZ too :)

[chasm]

Will do. This is on a project for a startup, but I will probably do a presentation at a local meetup in Wellington in the near future to talk about this. Will let you know.

[avkonst]

Let me know when you do talk. I might join.

[chasm]

That would be great. Are you in Wellington?

Here is what I'm doing with hookstate:

import { createStateLink, useStateLink } from '@hookstate/core'
import { Validation } from '@hookstate/validation'
import { Initial } from '@hookstate/initial'
import { Touched } from '@hookstate/touched'

export default function useFormState(initialState = {}, validators = []) {
  const state = createStateLink({}, link => {
    link
      .with(Initial)
      .with(Touched)
      .with(Validation)

    validators.forEach(v =>
      Validation(link.nested[v.name]).validate(v.validator, v.message),
    )

    return Object.keys(initialState).reduce(
      (acc, key) =>
        Object.defineProperty(acc, key, {
          get: function() {
            return link.nested[key].get()
          },
          set: function(val) {
            link.nested[key].set(val)
          },
        }),
      {
        isDirty: name =>
          name
            ? Initial(link.nested[name]).modified()
            : Initial(link).modified(),
        isTouched: name =>
          name ? Touched(link.nested[name]).touched() : Touched(link).touched(),
        isValid: name =>
          name
            ? Validation(link.nested[name]).valid()
            : Validation(link).valid(),
        isShallowValid: () => Validation(link).validShallow(),
        errors: name =>
          name
            ? Validation(link.nested[name]).errors()
            : Validation(link).errors(),
        firstError: name =>
          name
            ? Validation(link.nested[name]).firstError()
            : Validation(link).firstError(),
      },
    )
  })

  return useStateLink(state)
}

Then:

import React from 'react'
import useFormState from '@state/useFormState'

import { EMAIL_CHECK, PASSWORD_CHECK } from '@utils/constants'

const ExampleComponent = () => {
  const formState = useFormState(
    {
      email: '[email protected]',
      password: 'xyz123ABC!',
    },
    [
      {
        name: 'email',
        validator: (email = '') => EMAIL_CHECK.test(email),
        message: 'Email must be valid.',
      },
      {
        name: 'email',
        validator: (email = '') => email.length > 5,
        message: 'Email must be at least 5 characters long.',
      },
      {
        name: 'password',
        validator: (password = '') => PASSWORD_CHECK.test(password),
        message: 'Password must be valid.',
      },
    ],
  )

  return (
    <div style={{ margin: '0 100px 300px' }}>
      <p>Email: {formState.email}.</p>
      <p>Valid? {formState.isValid('email').toString()}.</p>
      <p>All valid? {formState.isValid().toString()}.</p>
      <pre>Errors? {JSON.stringify(formState.errors(), null, 2)}</pre>
      <pre>
        Email errors? {JSON.stringify(formState.errors('email'), null, 2)}
      </pre>
      <pre>
        Password errors? {JSON.stringify(formState.errors('password'), null, 2)}
      </pre>
      <p>First error? {JSON.stringify(formState.firstError(), null, 2)}</p>
      <p>
        First email error?{' '}
        {JSON.stringify(formState.firstError('email'), null, 2)}
      </p>
      <p>
        First password error?{' '}
        {JSON.stringify(formState.firstError('password'), null, 2)}
      </p>
    </div>
  )
}

export default ExampleComponent

Of course, eventually the form schema will be imported and injected into useFormState. I may also generate the form itself from the schema. We'll see.

[avkonst]

you can improve your useFormState by replacing const state = createStateLink by return useStateLink and dropping the last line. It will work the same way as useStateLink has got transform argument too. This way, each new rerender will avoid creating the state (might be not very important for your app).

[chasm]

Thanks! Good to know.