gregberge / recompact Goto Github PK

Can we get withStateHandlers too please?

Here's a little code snippet to demonstrate the problem:

import cc from 'classcat';
import {withPropsOnChange} from 'recompact';

export default function className(klass) {
    console.log('helllo',klass);
    return withPropsOnChange(['className'], ({className}) => {
        let tmp = klass || className;
        console.log('TTTTTTTTMPPPPPPPPPPPPP',tmp,klass,className);
        if(tmp) {
            return {
                className: klass && className
                    ? cc([klass,className])
                    : tmp
            }
        }
    });
}

When className is undefined, recompose will print "TTTTTTTTMPPPPPPPPPPPPP" but recompact will not.

i.e., recompact doesn't execute the function when shouldMapOrKeys refers to undefined props.

I understand why it may have implemented this way -- normally when using this HOC you're computing a new value from the old value, and if the old value is undefined the new one usually will be too -- but in this case I still want it to run.

Edit: Actually, I don't know what's going on. It looks like this should unconditionally execute, but it doesn't. All I know is the behaviour is different between recompose and recompact.

acdlite/recompose#366

SRP :)

hi.

abstract part of my real code:

compose(
  withState('status', 'setStatus', {}),
  withProps(
    ({ setStatus }) => ({
      go(key) {
        setStatus((prevState) => ({
          ...prevState,
          [key]: true
        }), () => console.log('done!'));
      }
    })
  )
)(Test);

no log. but it works fine with HOCs imported from recompose.

• No callback in withState
• branch right optional
• mapPropsStream uses Rx

It should not trigger "undefined" if it's not necessary.

acdlite/recompose#330

https://github.com/acdlite/recompose/pull/353/files
acdlite/recompose#348

The first example on your front page is:

import recompact from 'recompact'
import { pure, withProps } from 'recompact'

const enhance = recompact.compose(

To a library outsider (especially one coming from recompose where compose is just another import) that looks weird: why isn't it simply:

import { compose, pure, withProps } from 'recompact'

const enhance = compose(

?

At the very least ES6 syntax allows for combining those two lines into one:

import recompact, { pure, withProps } from 'recompact'

But since these are literally the first lines of code a newcomer to your library will see, it might be be nice if you could just add a one-line comment or something to explain why such a functionally-focused library requires compose to be imported/used as a method rather than as a stand-alone function.

Hi, can we simply use the types of Recompose or does this library needs its own set to properly support Flow?

Thanks.

Hello, I tried substituting recompose with this, and everything works great so far except for the HOCs not being compacted:

Here's what I'm doing to my component:

export default compose(
  setDisplayName('Home'),
  connect(mapStateToProps),
  lifecycle(spec),
  withHandlers(handlers),
)(Home);

Everything is imported from recompact and I even removed recompose so it can't be that. Did I miss something? Oh and I'm using the latest version 2.3.2

acdlite/recompose@af6e71a

On the current project, we ran into mysterious bugs when placing two react-apollo graphql() HOCs in the same compose() chain. Turned out that because each was followed by a withProps() (ie compose(graphql(), withProps(), graphql(), withProps())) and graphql() uses hoist-non-react-statics to hoist statics, bugs were because graphql() was hoisting the "internal" symbol statics that recompact uses to identify other components as fellow "compactable" Recompact HOCs, so withProps() thought that graphql() was another Recompact HOC that it could condense or whatever (at least this is my understanding)

So my solution was to fork recompact to export the symbols it uses as keys for static properties (opened #95) and fork react-apollo to accept a blacklist of keys not to hoist (which can then be passed the exported recompact symbols)

However, then this week ran into the same issue using a different HOC (withNavigation() from react-navigation) which also hoists statics using hoist-non-react-statics. So hoping there's a better approach than trying to get various third-party HOCs to accept a hoist blacklist. This feels at this point like a flaw in the way recompact identifies other recompact HOCs, since it's considered best practice for HOCs to hoist statics (which to my understanding then causes bugs whenever it sits between two recompact HOCs), but not sure if there's another mechanism besides statics that recompact could use to identify other recompact HOCs?

I'm seeing the following warnings

warning Unmet peer dependency "rxjs@^5.0.0-beta.10".
warning Unmet peer dependency "rxjs@^5.0.0-rc.4".

I think that we can increase the peer dependency scope.

acdlite/recompose#185

UPD: PR is here #99

'Symbol' is undefined throwed by node_modules/recompact/utils/createCompactableHOC.js in IE 11.

Bundled version of createCompactableHOC:

"use strict";


exports.__esModule = true;

var _createHOCFromMapper = __webpack_require__("./node_modules/recompact/utils/createHOCFromMapper.js");

var compactable = Symbol('compactable'); /* eslint-disable no-param-reassign */

var isCompactable = function isCompactable(Component) {
  return typeof Component === 'function' && Component[compactable];
};

exports.default = function (createCompactableComponent, createComponent) {
  return function (BaseComponent) {
    if (isCompactable(BaseComponent)) {
      BaseComponent = BaseComponent[compactable];
    }

    var Component = createComponent(BaseComponent);
    Component[compactable] = createCompactableComponent(BaseComponent);

    if ((0, _createHOCFromMapper.isMapperComponent)(BaseComponent)) {
      return Component[compactable];
    }

    return Component;
  };
};

https://github.com/jdalton/docdown

Are there any plans to support TypeScript?

• getDisplayName
• wrapDisplayName
• shallowEqual
• isClassComponent
• isReferentiallyTransparentFunctionComponent
• createEagerElement
• createEagerFactory
• createSink
• componentFromProp
• nest
• hoistStatics
• setStatic
• setPropTypes
• setDisplayName
• toClass
• utils/pick
• utils/omit
• utils/createEagerElementUtil

acdlite/recompose#303

Since the README mentions that there is some improvements in performance over recompose, it would be nice to provide those in the README or at least in a linked document so people could see them without needing to install and run them for themselves.

Knowing the relative scope of the performance improvement is key for people to know if that is a relevant factor.

Hey guys. I see v3.3.0 was created a couple days ago, but I got v3.2.1 from npm. Can someone have a look why is this so?

Specifically, I expected withStateHandlers to be available, as I try to replace recompose with recompact