render React component, with scope[attrs.props] being passed in as the component props
168155
function renderComponent(component, props, scope, elem) {
    scope.$evalAsync(function() {
      ReactDOM.render(React.createElement(component, props), elem[0]);
    });
  }
990894
function Header({
  RootComponent,
  className,
  children,
  size = 1,
}: Props): React.Node {
  const classes = cn(`h${size}`, className);
  const Component = RootComponent || "div";
  return <Component className={classes}>{children}</Component>;
}
746646
function initRender (vm) {
  vm._vnode = null; // the root of the child tree
  vm._staticTrees = null;
  var parentVnode = vm.$vnode = vm.$options._parentVnode; // the placeholder node in parent tree
  var renderContext = parentVnode && parentVnode.context;
  /**
   * react-vue change
   */
  // vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext)
  vm.$scopedSlots = emptyObject;
  // bind the createElement fn to this instance
  // so that we get proper render context inside it.
  // args order: tag, data, children, normalizationType, alwaysNormalize
  // internal version is used by render functions compiled from templates
  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
  // normalization is always applied for the public version, used in
  // user-written render functions.
  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
}
419872
def render_react_component(component, data = {})
      begin
        new_data = get_view_data(component, data)
      rescue StandardError => e
        on_error(e)
        new_data = data
      end
      job = {
        :data => new_data,
        :name => component,
      }

      hypernova_batch_render(job)
    end
283928
function jsnox(React) {
    var client = function jsnoxClient(componentType, props, children) {
        // Special $renderIf prop allows you to conditionally render an element:
        //if (props && typeof props.$renderIf !== 'undefined') {
        if (props && typeof props === 'object' && props.hasOwnProperty('$renderIf')) {
            if (props.$renderIf) delete props.$renderIf     // Don't pass down to components
            else return null
        }

        // Handle case where an array of children is given as the second argument:
        if (Array.isArray(props) || typeof props !== 'object') {
            children = props
            props = null
        }

        // Handle case where props object (second arg) is omitted
        var arg2IsReactElement = props && React.isValidElement(props)

        var finalProps = props
        if (typeof componentType === 'string' || !componentType) {
            // Parse the provided string into a hash of props
            // If componentType is invalid (undefined, empty string, etc),
            // parseTagSpec should throw.
            var spec = parseTagSpec(componentType)
            componentType = spec.tagName
            finalProps = arg2IsReactElement ? spec.props : extend(spec.props, props)
        }

        // If more than three args are given, assume args 3..n are ReactElement
        // children. You can also pass an array of children as the 3rd argument,
        // but in that case each child should have a unique key to avoid warnings.
        var args = protoSlice.call(arguments)
        if (args.length > 3 || arg2IsReactElement) {
            args[0] = componentType
            if (arg2IsReactElement) {
                args.splice(1, 0, finalProps || null)
            } else {
                args[1] = finalProps
            }
            return React.createElement.apply(React, args)
        } else {
            return React.createElement(componentType, finalProps, children)
        }
    }
    client.ParseError = ParseError
    return client
}
795708
function(publicInstance, partialProps) {
    var internalInstance = getInternalInstanceReadyForUpdate(
      publicInstance,
      'setProps'
    );

    if (!internalInstance) {
      return;
    }

    ("production" !== process.env.NODE_ENV ? invariant(
      internalInstance._isTopLevel,
      'setProps(...): You called `setProps` on a ' +
      'component with a parent. This is an anti-pattern since props will ' +
      'get reactively updated when rendered. Instead, change the owner\'s ' +
      '`render` method to pass the correct value as props to the component ' +
      'where it is created.'
    ) : invariant(internalInstance._isTopLevel));

    // Merge with the pending element if it exists, otherwise with existing
    // element props.
    var element = internalInstance._pendingElement ||
                  internalInstance._currentElement;
    var props = assign({}, element.props, partialProps);
    internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(
      element,
      props
    );

    enqueueUpdate(internalInstance);
  }
37666
function renderAttributes(ns, node, attrs) {
  let map = ATTRIBUTE_MAP[ns] || {};
  keys(map).forEach(key => {
    let attrKey = map[key];
    if(key in attrs) {
      node.setAttribute(attrKey, attrs[key]);
    }
  });
}
855258
function componentDidMount() {
        var _this2 = this;

        Object.keys(renamedProps).forEach(function (prop) {
          if (prop in _this2.props) {
            console.warn(warningMessage({
              componentName: getComponentName(WrappedComponent),
              prop: prop,
              renamedProps: renamedProps
            }));
          }
        });
      }
522341
function (props, propName, componentName) {
    // Only accept a single child, of the appropriate type
    //credits: http://www.mattzabriskie.com/blog/react-validating-children
    let prop = props[propName];
    let types = ['svg'];
    if (React.Children.count(prop) !== 1 ||
      types.indexOf(prop.type) === -1) {
      return new Error(
        '`' + componentName + '` ' +
        'should have a single child of the following types: ' +
        ' `' + types.join('`, `') + '`.'
      );
    }
    if (!prop.props.hasOwnProperty('width') || !prop.props.hasOwnProperty('height')) {
      return new Error('SVG should have props `width` and `height`');
    }

  }
146098
function() {
    if ("production" !== "development") {
      var owner = ReactCurrentOwner.current;
      if (owner !== null) {
        ("production" !== "development" ? warning(
          owner._warnedAboutRefsInRender,
          '%s is accessing isMounted inside its render() function. ' +
          'render() should be a pure function of props and state. It should ' +
          'never access something that requires stale data from the previous ' +
          'render, such as refs. Move this logic to componentDidMount and ' +
          'componentDidUpdate instead.',
          owner.getName() || 'A component'
        ) : null);
        owner._warnedAboutRefsInRender = true;
      }
    }
    var internalInstance = ReactInstanceMap.get(this);
    return (
      internalInstance &&
      internalInstance !== ReactLifeCycle.currentlyMountingInstance
    );
  }
854561
function TextBlock(props) {
  return _react2.default.createElement(
    'div',
    { className: props.className, onClick: props.onClick },
    props.text || ''
  );
}
1296662
function renderPages(pair) {
    return range(pair[0], pair[1]).map(function (pageIndex, index) {
      var _this = this;

      return React.createElement(Page, {
        key: index,
        isActive: this.props.current === pageIndex,
        className: "btn-numbered-page",
        onClick: function onClick() {
          return _this.handlePageChanged(pageIndex);
        }
      }, pageIndex);
    }.bind(this));
  }
539141
function renderSlot (
  name,
  fallback,
  props,
  bindObject
) {
  var scopedSlotFn = this.$scopedSlots[name];
  if (scopedSlotFn) { // scoped slot
    props = props || {};
    if (bindObject) {
      extend(props, bindObject);
    }
    return scopedSlotFn(props) || fallback
  } else {
    var slotNodes = this.$slots[name];
    // warn duplicate slot usage
    if (slotNodes && process.env.NODE_ENV !== 'production') {
      slotNodes._rendered && warn(
        "Duplicate presence of slot \"" + name + "\" found in the same render tree " +
        "- this will likely cause render errors.",
        this
      );
      slotNodes._rendered = true;
    }
    return slotNodes || fallback
  }
}
663252
function renderToString(element) {
  !React.isValidElement(element) ?  false ? invariant(false, 'renderToString(): You must pass a valid ReactElement.') : _prodInvariant('46') : void 0;
  return renderToStringImpl(element, false);
}
124483
def render(self, ctx=None):
        '''
        
        '''
        self._initialize()
        if ctx is None:
            ctx = RenderContext()
        #
        # if we are called from within render, return a dummy object...
        #
        if self in ctx:
            self._current_rendered = self._in_render_value()
        else:
            ctx.push(self)
            if self.dependency_type == Calculated.VALUE_BASED:
                self._rendered_field = self._field.render(ctx)
            self._render()
            ctx.pop()
        return self._current_rendered
415806
function( entireComponent ) {

                // Insert a new component holder in the root or box.
                if ( entireComponent ) P.$root.html( createWrappedComponent() )
                else P.$root.find( '.' + CLASSES.box ).html( P.component.nodes( STATE.open ) )

                // Trigger the queued “render” events.
                return P.trigger( 'render' )
            }
144202
function renderAttrs (attrs = {}) {
  const keys = Object.keys(attrs)
  if (keys.length) {
    return ' ' + keys.map(name => `${name}="${escape(attrs[name])}"`).join(' ')
  } else {
    return ''
  }
}