Render notification center in production mode.
@param {object} props props.
@returns {JsxElement} element.
760968
function NotificationCenterProd({ iconName, onSingleClick, store, panelFooter, panelHeader }) {
    return (
        <Provider store={store}>
            <NotificationCenter
                iconName={iconName}
                hasAddNotif={false}
                onSingleClick={onSingleClick}
                panelHeader={panelHeader}
                panelFooter={panelFooter}
            />
        </Provider>
    );
}
606760
function renderHtmlAst(node, { components }) {
  if (node.type === 'root') {
    // NOTE: wrap children with React.Fragment, to avoid div wrapper from `hast-to-hyperscript`
    node = {
      type: 'element',
      tagName: Fragment,
      properties: {},
      children: node.children,
    };
  }

  function h(name, props, children) {
    return React.createElement(
      getReactElement(name, components),
      props,
      getReactChildren(name, children),
    );
  }

  return toH(h, node);
}
1022131
async function publish(props) {
	const message = getData(props)
	return createClient()
		.post('/publish/', {
			json: true,
			body: message
		})
}
127648
function createAlertStyle(style) {
    return React.createClass({
        displayName: Alert.displayName + style,
        render() {
            return <Alert {...this.props} style={style.toLowerCase()} />;
        }
    });
}
1009393
function forFadeFromBottomAndroid(props) {
  const { layout, position, scene } = props;

  if (!layout.isMeasured) {
    return forInitial(props);
  }
  const interpolate = getSceneIndicesForInterpolationInputRange(props);

  if (!interpolate) return { opacity: 0 };

  const { first, last } = interpolate;
  const index = scene.index;
  const inputRange = [first, index, last - 0.01, last];

  const opacity = position.interpolate({
    inputRange,
    outputRange: [0, 1, 1, 0],
  });

  const translateY = position.interpolate({
    inputRange,
    outputRange: [50, 0, 0, 0],
  });
  const translateX = 0;

  return {
    opacity,
    transform: [{ translateX }, { translateY }],
  };
}
1127159
@Override
	public void renderHead(IHeaderResponse response) {
		super.renderHead(response);
		
		List<FeedbackMessage> msgs = model.getObject();
		if(msgs.size()>0){
			for(Component component: messages.keySet()){
				StringBuffer sb = new StringBuffer();
				for(FeedbackMessage msg : messages.get(component)){
					sb.append(msg.getMessage()+"\n");
					msg.markRendered();
				}
				
				String script = "$(\"#"+component.getMarkupId()+"\")"
						+ ".popover({ 'trigger': 'focus', "
								   + "'placement': 'top', "
								   + "'content': \""+StringEscapeUtils.escapeEcmaScript(sb.toString())+"\", "
								   + "'template': '<div class=\"popover feedback-popover\"><div class=\"arrow\"></div><div class=\"popover-inner\"><h3 class=\"popover-title\"></h3><div class=\"popover-content\"><p></p></div></div></div>'"
						+ "});";
				script += "$(\"#"+component.getMarkupId()+"\").keypress(function(){ $(\"#"+this.getMarkupId()+"\").removeClass('has-error'); $(this).popover('destroy'); });";
				response.render(OnDomReadyHeaderItem.forScript(script));
			}
		}
		
	}
774964
function renderToString(element) {
  !ReactElement.isValidElement(element) ? "development" !== 'production' ? invariant(false, 'renderToString(): You must pass a valid ReactElement.') : _prodInvariant('46') : void 0;
  return renderToStringImpl(element, false);
}
103340
function renderChildNodes(props, from, to) {
  const {
    nodeType,
    data,
    collectionLimit,
    circularCache,
    keyPath,
    postprocessValue,
    sortObjectKeys
  } = props;
  const childNodes = [];

  getCollectionEntries(
    nodeType,
    data,
    sortObjectKeys,
    collectionLimit,
    from,
    to
  ).forEach(entry => {
    if (entry.to) {
      childNodes.push(
        <ItemRange
          {...props}
          key={`ItemRange--${entry.from}-${entry.to}`}
          from={entry.from}
          to={entry.to}
          renderChildNodes={renderChildNodes}
        />
      );
    } else {
      const { key, value } = entry;
      const isCircular = circularCache.indexOf(value) !== -1;

      const node = (
        <JSONNode
          {...props}
          {...{ postprocessValue, collectionLimit }}
          key={`Node--${key}`}
          keyPath={[key, ...keyPath]}
          value={postprocessValue(value)}
          circularCache={[...circularCache, value]}
          isCircular={isCircular}
          hideRoot={false}
        />
      );

      if (node !== false) {
        childNodes.push(node);
      }
    }
  });

  return childNodes;
}
126154
function warnForPropsMutation(propName, element) {
  var type = element.type;
  var elementName = typeof type === 'string' ? type : type.displayName;
  var ownerName = element._owner ?
    element._owner.getPublicInstance().constructor.displayName : null;

  var warningKey = propName + '|' + elementName + '|' + ownerName;
  if (warnedPropsMutations.hasOwnProperty(warningKey)) {
    return;
  }
  warnedPropsMutations[warningKey] = true;

  var elementInfo = '';
  if (elementName) {
    elementInfo = ' <' + elementName + ' />';
  }
  var ownerInfo = '';
  if (ownerName) {
    ownerInfo = ' The element was created by ' + ownerName + '.';
  }

  ("production" !== "development" ? warning(
    false,
    'Don\'t set .props.%s of the React component%s. Instead, specify the ' +
    'correct value when initially creating the element or use ' +
    'React.cloneElement to make a new element with updated props.%s',
    propName,
    elementInfo,
    ownerInfo
  ) : null);
}
566819
function Icon({
  prefix: prefixFromProps = "fe",
  name,
  className,
  link,
  isAriaHidden,
  payment,
  flag,
  onClick,
  onMouseEnter,
  onMouseLeave,
  onPointerEnter,
  onPointerLeave,
  onFocus,
  onBlur,
}: Props): React.Node {
  const prefix = (payment && "payment") || (flag && "flag") || prefixFromProps;
  const classes = cn(
    {
      [prefix]: true,
      [`${prefix}-${name}`]: true,
    },
    className
  );
  const extraProps = isAriaHidden
    ? {
        "aria-hidden": "true",
      }
    : null;

  const eventProps = {
    onClick,
    onMouseEnter,
    onMouseLeave,
    onPointerEnter,
    onPointerLeave,
    onFocus,
    onBlur,
  };

  return !link ? (
    <i className={classes} {...eventProps} />
  ) : (
    <a className="icon" {...extraProps} {...eventProps}>
      <i className={classes} />
    </a>
  );
}
1175042
function renderToStaticMarkup(element) {
  !ReactElement.isValidElement(element) ? "development" !== 'production' ? invariant(false, 'renderToStaticMarkup(): You must pass a valid ReactElement.') : _prodInvariant('47') : void 0;
  return renderToStringImpl(element, true);
}
693536
function Button(props) {
  let {
    label,
    href,
    type,
    size,
    children,
    className,
    primary,
    secondary,
    outline,
    flat,
    ...rest
  } = props
  /* Add className */
  const classes = cx(
    buttonClassName,
    {
      [`${buttonClassName}-primary`]: primary,
      [`${buttonClassName}-secondary`]: secondary,
      [`${buttonClassName}-outline`]: outline,
      [`${buttonClassName}-flat`]: flat,
      [`${buttonClassName}-${type}`]: type,
    },
    `${buttonClassName}-${size}`,
    className
  )

  const tagName = href ? 'a' : 'button'

  return React.createElement(
    tagName,
    {
      className: classes,
      href,
      ...rest,
    },
    children || label
  )
}
987201
function Segment(props) {
    var segmentStyle = props.segmentStyle;
    var fillStyle = props.fillStyle;

    var commonStyle = { position: 'absolute' };
    return React.createElement(
      'div',
      { style: _extends({}, commonStyle, segmentStyle) },
      React.createElement('div', { style: _extends({}, commonStyle, fillStyle) })
    );
  }
938242
function Toolbar(props, context) {
	const { ui } = props;

	return <div className="tools">
			<FilterSelector ui={ ui } />
			<SortSelector ui={ ui } />
		</div>
}
669092
function List(props) {
        var tag = props.type.toLowerCase() === 'bullet' ? 'ul' : 'ol';
        var attrs = getCoreProps(props);

        if (props.start !== null && props.start !== 1) {
            attrs.start = props.start.toString();
        }

        return createElement(tag, attrs, props.children);
    }
1219795
function Hint(props) {
  const { getHintProps } = useFieldContext();
  const checkboxCtx = useCheckboxContext();
  const radioCtx = useRadioContext();
  const toggleCtx = useToggleContext();

  let HintComponent = StyledTextHint;
  const commonProps = {
    'data-garden-version': PACKAGE_VERSION
  };

  if (checkboxCtx) {
    HintComponent = StyledCheckHint;
    commonProps['data-garden-id'] = 'forms.checkbox_hint';
  } else if (radioCtx) {
    HintComponent = StyledRadioHint;
    commonProps['data-garden-id'] = 'forms.radio_hint';
  } else if (toggleCtx) {
    HintComponent = StyledToggleHint;
    commonProps['data-garden-id'] = 'forms.toggle_hint';
  } else {
    commonProps['data-garden-id'] = 'forms.text_hint';
  }

  return React.createElement(
    HintComponent,
    getHintProps({
      ...commonProps,
      ...props
    })
  );
}
991846
function getIconSize(props) {
  const { spacing } = props.theme;
  const { icon } = props.style;

  if (icon && icon.width) {
    return icon.width;
  }
  if (props.size) {
    return props.size;
  }

  return spacing.iconSize;
}