couzic / lenrix Goto Github PK

View Code? Open in Web Editor NEW

24.0 4.0 1.0 817 KB

Type-safe, reactive, focusable redux store wrapper

License: MIT License

TypeScript 98.95% JavaScript 1.05%

rxjs state-management immutable lens typescript redux epics

lenrix's People

Contributors

Stargazers

Watchers

Forkers

c-jacquin

lenrix's Issues

Enable custom change detection strategy

store.changeDetectionStategies({
    myValue: (previousValue, nextValue) => previousValue.myField === nextValue.myField
})

Since this case is so common:

store.changeDetectionSelectors({
    birthDate: _  => _.getTime()
})

Store.path()

Throw error when compute() or compute$() overwrites existing state field

computeFromField() & computeFromField$()

Store.pluck() to accept path

Store.updateFieldValues()

Add the ability to do something like:

store.updateFieldValues(state => ({
   prop1: state.prop2,
   prop2: state.prop1
}))

Requires lenrix #4 to be solved first

Rename FieldLenses to CherryPick

Rename "actionHandlers()" to "updaters()"

Store.updates.shouldNotCompile

// Registering update with unknown action @shouldNotButDoesCompile
store.updates(_ => ({
   doString: s => _.focusPath('counter').setValue(42),
   unknown: s => _.focusPath('counter').setValue(42),
}))

Logger global shutdown switch

When testing, logging should be completely disabled.

Use Readonly<> whenever possible

Actions

Define and implement the API to allow the dispatch and handling of actions on a Store. Open questions:

SIngle VS multiple action handlers
Handle actions on rootStore only ?
Local actions ?

computeFromField() & computeFromField$()

Syntactic sugar for computeFromField(['singleField'], singleField => ...)

computeFrom() computeFrom$() computeFromFields() computeFromFields$() should make store (light) available

Design and implement proper error handling strategy

Console logger: computedValues diff with "previous" and "next" rather than on same line

Store.focusFields()

Syntactic sugar for Store.recompose()

LightStore instances should hide actual full-fledged store behind a proxy

Hide store reference behind proxy LightStore instance

webpack hot module reload support

In order to make webpack hot module reload work properly we need to have something like this to update the store when an update, a computed value or an epic is modified.

redux and redux-observable already implement this feature.

Do you think it is possible ? easy ?

if (module.hot) {
  module.hot.accept('../reducers', () =>
    store.replaceReducer(require('../reducers')) // eslint-disable-line global-require
  );

  const epic$ = new BehaviorSubject(rootEpic);
  module.hot.accept('./where-ever-they-are', () => {
    const nextRootEpic = require('./where-ever-they-are').rootEpic;
    epic$.next(nextRootEpic);
  });
}

https://redux-observable.js.org/docs/recipes/HotModuleReplacement.html

Replace references to MergedFields with a better alternative

rename select() to pluck()

Console logger: Single line when update and epic

Store.compute$() - state$ and computedState$ emit twice

Pass updatable state fields down focused store as readonly fields

store
.computeFromFields(
  ['selectedStatsProduct'],
  ({ selectedStatsProduct }) => ({
    selectedStatsProduct,
  }),
)
.focusPath(
  [...],
  ['selectedStatsProduct'],
)

should be:

store
.focusPath(
  [...],
  ['selectedStatsProduct'],
)

Rename registerHandlers() and move it to StoreContext

focusPath() should accept single param

Rename setValue() => set()

Store.reset()

Useful to set state or slice of state back to initial state

Make logger configurable on store instances

Logger should be configured at the store level, enabling logging from only single store to reduce console noise.

Rename Store.extract() to .cherryPick()

Tests: follow a single convention when counting state transitions

computeFromFields() emits undefined computed values before first computation

Prevent publishing new version when test folder accidentally included in /lib

updatable fields VS readonly fields

Think of and implement a better API

updates()
currentState

computeFrom() does not recompute when focused field is undefined

  .computeFrom(
    _ => ({
      selectedCategoryProduct: _.focusPath(
        'productSelect',
        'selectedCategoryProduct',
      ),
    }),
    ({ selectedCategoryProduct }) => ({
      statsProductOptions:
        selectedCategoryProduct === undefined
          ? undefined
          : selectedCategoryProduct.products.map(toOption),
    }),
  )

Problem: statsProductOptions never get undefined

Namespaced actions

Suppress code duplication between FocusedStore and RootStore classes

One class might be enough

computeFromAction$()

Make sure errors are thrown when functions are passed where empty objects are legal

Store.focusFields() to NOT return Pick type for better lisibility

action$ in Store and LightStore

Option for deepFreeze

Remove all references to currentComputedState and computedState$

currentState should hold all readonly fields

computeFromFields$() lacks distinctUntilChanged() on selection$

extract()

Example:

const extract$: Observable<{a: A, c: C}> = store.extract({
   a: store.lens.focusOn('a'),
   c: store.lens.focusOn('b').focusOn('c')
})

extract$ only emits for new values of a or c