danielyogel / vertical

Vertical Abstract Software

Vertical

Goals

1. Declerative Ui description (full-stack planned)
2. Auto parent child relationship - parent aggregates children data, children auto-pass parent data.
3. Audo bindings of nodes by key.
4. Cross concern auto deps - for example disabled when loading
5. Statically typed API.
6. Statically typed data.
7. 100% cusomizable - prefer composability over inheritence and/or big config.
8. Dependecy Injection
9. Future: Dynamic children (for editors and similar)
10. Future: Auto Normalization/Denormalization of API response
11. Backend' data driven UI

vertical's Issues

'subscribing/initing' anything in a node

Add ‘base’ mixin

use "withBase" mixin in all nodes

Allow Extending Parent Params

1. Extending the child's parent params.
2. Extending the parent's params passed to child

Improve types and code - add children to basenode

Non 'logical' children (?)

Allow specifying children that are not related to the parent's value.
Like a child for some button...
Should be marked as "non-logical", so type safety does not break, and non-logical children are explicitly marked (typos for logical children should still not compile).

Add mixin-less implementation of the whole library

Title (and etc) Should Be a Function

configurable 'currentIndex'

1. Implement Get
2. Implement Set

Simplify Code

1. Move one time used types from BaseVM
2. Removed one time used mixins (views)
3. Make things optional

Refactor Existing Mixins

• So 'developer level' Usage Could Depend On Mixins Easely (withBase, withChildren...)

Add XO linter

Title should be computed

all code should be inside mixins

withArrayParent.ts
withArrayChildParent.tsx
withDynamicChildParent.ts
withRecordParent.ts
withSkalarParent.ts

• maybe some of them can be unified as well...
• where should they be placed?

Allow extending the 'children' type

General Refactors

Editor

Allow creating reactive options that depend on parent and other state

Implement "NodeObjectLogical" an "NodeDynamicArrayChildLogical"

VERY VERY SIMILAR to "NodeArrayChildLogical" - which is already implemented

Context

1. allow any node to change the context bottom-down

Refactor Node Kinds

Important: A nodeKind should be wrappale (like extended in classes)

1. NodeSkalar
2. NodeOneOf
3. NodeObject
   -- children are (Record<string, node>)
   -- binds value and onChange by key
4. NodeLogical
   -- children are (Record<string , node> | Array)
   -- pass value and onchange as is (partial onChange)

feat: all node instances must be nestable be other nodes

TODO:

1. NodeArrayChild: withArrayChildParent<S, S> - First "S" may be different, so use some "V"...

Migrate to Vite (!)

Vertical Should Handle V - valid type, and mark the type of valid on change somehow

Extract more mixins out of nodes

Dynamic Children

Consider Changing The Type Infer Direction

1. May simplify code?
2. Any problem?
3. Just make a branch?
4. Write down "plus VS minus"

minuses

1. makes the form less generic, you can not initiate forms un related to specific data, the only solution would be mapping the data in input/output

Remove withOptions + add title, description…

Add Wizard Support

Modify 'withSelected' to be what it's supposed to be

Ways To Extend

1. Existing mixin's options
2. create a new node class using existing mixins and/or wrapping existing classes
3. add an 'option/sub-types/etc' type variable
4. goes all the way to the view

Find a better 'flow' function

Key should be inferred + label computed

Add 'withState' (or 'withStore') mixin.

1. should start a new 'split point'...
   2.consider implementing "sync/persist/ajax" declarative utils.

Allow a child to be just a function

Add UUID

https://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid

Allow Computed Props to Aggregate Children