Nefarious Pomegranate Magnate
    Have ideas to improve npm?Join in the discussion! »

    react-lifecycle-visualizer
    TypeScript icon, indicating that this package has built-in type declarations

    2.2.12 • Public • Published

    React Lifecycle Visualizer npm version Build Status

    An npm package (react-lifecycle-visualizer) for tracing & visualizing lifecycle methods of arbitrary React components.

    To trace a component, apply the higher-order component traceLifecycle to it, and all its lifecycle-method calls will show up in a replayable log component. Additionally, traced components may include a <this.props.LifecyclePanel/> element in their rendering to show a panel with lifecycle methods, which are highlighted when the corresponding log entry is selected.

    Parent-child demo

    Usage

    The easiest way to get started is to open the StackBlitz project and edit the sample components in src/samples. (For a better view of the log, press the 'Open in New Window' button in the top-right corner.)

    The panel shows the new React 16.3 lifecycle methods, unless the component defines at least one legacy method and no new methods. On a component that has both legacy and new methods, React ignores the legacy methods, so the panel shows the new methods.

    Though technically not lifecycle methods, setState & render are also traced. A single setState(update, [callback]) call may generate up to three log entries:

    1. 'setState' for the call itself.
    2. If update is a function instead of an object, 'setState:update fn' is logged when that function is evaluated.
    3. If a callback function is provided, 'setState:callback' is logged when it's called.

    To save space, the lifecycle panel only contains setState, which gets highlighted on any of the three events above.

    Run the demo locally

    To run a local copy of the StackBlitz demo, simply clone the repo, and run npm install & npm start:

    git clone git@github.com:Oblosys/react-lifecycle-visualizer.git
    cd react-lifecycle-visualizer
    npm install
    npm start
    

    The demo runs on http://localhost:8000/.

    Using the npm package

    $ npm i react-lifecycle-visualizer

    Setup

    To set up tracing, wrap the root or some other ancestor component in a <VisualizerProvider> and include the <Log/> component somewhere. For example:

    import { Log, VisualizerProvider } from 'react-lifecycle-visualizer';
    
    ReactDom.render(
      <VisualizerProvider>
        <div style={{display: 'flex'}}>
          <App/>
          <Log/>
        </div>
      </VisualizerProvider>,
      document.getElementById('root')
    );

    If you're using a WebPack dev-server with hot reloading, you can include a call to resetInstanceIdCounters in the module where you set up hot reloading:

    import { resetInstanceIdCounters } from 'react-lifecycle-visualizer';
    ..
    resetInstanceIdCounters(); // reset instance counters on hot reload
    ..

    This isn't strictly necessary, but without it, instance counters will keep increasing on each hot reload, making the log less readable.

    Tracing components

    To trace a component (e.g. ComponentToTrace,) apply the traceLifecycle HOC to it. This is most easily done with a decorator.

    import { traceLifecycle } from 'react-lifecycle-visualizer';
    ..
    @traceLifecycle
    class ComponentToTrace extends React.Component {
      ..
      render() {
        return (
          ..
          <this.props.LifecyclePanel/>
          ..
        );
      }
    }

    Alternatively, apply traceLifecycle directly to the class, like this:

    const ComponentToTrace = traceLifecycle(class ComponentToTrace extends React.Component {...});

    or

    class ComponentToTraceOrg extends React.Component {...}
    const ComponentToTrace = traceLifecycle(ComponentToTraceOrg);

    Traced component props: LifecyclePanel and trace

    The traced component receives two additional props: LifecyclePanel and trace. The LifecyclePanel prop is a component that can be included in the rendering with <this.props.LifecyclePanel/> to display the lifecycle methods of the traced component.

    render() {
      return (
        ..
        <this.props.LifecyclePanel/>
        ..
      );
    }

    The trace prop is a function of type (msg: string) => void that can be used to log custom messages:

    componentDidUpdate(prevProps, prevState) {
      this.props.trace('prevProps: ' + JSON.stringify(prevProps));
    }

    In the constructor we can use this.props.trace after the call to super, or access trace on the props parameter:

    constructor(props) {
      props.trace('before super(props)');
      super(props);
      this.props.trace('after super(props)');
    }

    In the static getDerivedStateFromProps we cannot use this to refer to the component instance, but we can access trace on the nextProps parameter:

    static getDerivedStateFromProps(nextProps, prevState) {
        nextProps.trace('nextProps: ' + JSON.stringify(nextProps));
        ..
    }

    TypeScript

    There's no need to install additional TypeScript typings, as these are already included in the package. The interface TraceProps declares the trace and LifecyclePanel props. Its definition is

    export interface TraceProps {
      trace: (msg: string) => void,
      LifecyclePanel : React.SFC
    }

    With the exception of tracing a component, the TypeScript setup is the same as the JavaScript setup above. Here's an example of a traced component in TypeScript:

    import { traceLifecycle, TraceProps } from 'react-lifecycle-visualizer';
    ..
    interface ComponentToTraceProps extends TraceProps {}; // add trace & LifecyclePanel props
    interface ComponentToTraceState {}
    
    class ComponentToTrace extends React.Component<ComponentToTraceProps, ComponentToTraceState> {
      constructor(props: ComponentToTraceProps, context?: any) {
        props.trace('before super(props)');
        super(props, context);
        this.props.trace('after super(props)');
      }
    
      static getDerivedStateFromProps(nextProps : ComponentToTraceProps, nextState: ComponentToTraceState) {
        nextProps.trace('deriving');
        return null;
      }
    
      render() {
        return <this.props.LifecyclePanel/>;
      }
    }

    The only difference is that we cannot use traceLifecycle as a decorator in TypeScript, because it changes the signature of the parameter class (see this issue). Instead, we simply apply it as a function:

    const TracedComponent = traceLifecycle(ComponentToTrace);

    Install

    npm i react-lifecycle-visualizer

    DownloadsWeekly Downloads

    43

    Version

    2.2.12

    License

    MIT

    Unpacked Size

    109 kB

    Total Files

    29

    Last publish

    Collaborators

    • avatar