forest. Returning some stores(or probably another units) from component. Pattern or AntiPatern?

[ilyaagarkov]

This code looks very useful to me.
It's a way to reuse some components with getting access to their "internal state"

But I know nothing about forest
Is it a good idea or it might provide some problems?

function FiltersForm() {
  const filterChanged = createEvent<string>();
  const $filter = restore(filterChanged, '');

  const searchChanged = filterChanged.prepend(
    (e: Event | KeyboardEvent) => (e.currentTarget as HTMLInputElement)?.value,
  );

  Header(() => {
    Search({
      attr: {
        value: $filter,
        placeholder: 'Type a part of store name',
      },
      handler: { input: searchChanged },
    });
  })

  return { $filter }
}

[tehSLy]

If resulting units are planned to be used further, I would rather go with separated View and Model layers, e.g.:

function createFiltersFormModel(config) {
   const $filter = createStore(...);
   ...
   return { $filter, searchChanged, filterChanged }
}

function FiltersForm(model) {
   Header(() => {
    Search({
      attr: {
        value: model.$filter,
        placeholder: 'Type a part of store name',
      },
      handler: { input: model.searchChanged },
    });
  })
}

[ilyaagarkov]

for the current case, It makes sense

but It's just an example. And if I reuse this form a lot of time it might be annoying
And also if we split it to model and view we have all units as public API for the model.

If we return it from the component we able to hide something from the user

[tehSLy]

Implicit units still may be kept within the View layer, e.g.:

function createModel(...) { ... }

function View(model) {
   const implicitEvent = model.prepend(...);
   h('div', ...);
}

Thus only public API is exposed and implicit units are encapsulated
Considering this case, what exactly annoys you in terms of reusing? If some kind of form is quite common across the app it simply may be reduced to another factory:

function UserForm(...) {
   ...
   Form({model: userModel, ...});
}

I think mixing View side-effects and Model definition is never a good idea because logic/behavior sharing becomes much more sophisticated.