@kiwicom/smart-faq/src/SmartFAQ/context/User.js

// @flow

import * as React from 'react';

import type { User, onLogin, onLogout } from '../../types';

type TokenTypes = {|
  simpleToken: ?string,
  loginToken: ?string,
  kwAuthToken: ?string,
|};

export type UserContextType = {|
  user: ?User,
  brand: string,
  onLogin: onLogin,
  onLogout: onLogout,
  ...TokenTypes,
|};

export const UserContext: React.Context<UserContextType> = React.createContext(
  ({
    user: null,
    brand: 'kiwicom',
    loginToken: null,
    simpleToken: null,
    kwAuthToken: null,
    onLogin: () => {},
    onLogout: () => Promise.resolve(null),
  }: UserContextType),
);

/* @deprecated - use Context directly */
export const withLogin = <Config: { onLogin?: onLogin }>(
  Component: React.AbstractComponent<Config>,
): React.AbstractComponent<$Diff<Config, { onLogin?: onLogin }>> =>
  function withLoginHOC(props: $Diff<Config, { onLogin?: onLogin }>) {
    return (
      <UserContext.Consumer>
        {({ onLogin }: UserContextType) => (
          <Component {...props} onLogin={onLogin} />
        )}
      </UserContext.Consumer>
    );
  };

/* @deprecated - use Context directly */
export const withUser = <Config: { user?: ?User }>(
  Component: React.AbstractComponent<{ user?: ?User }>,
): React.AbstractComponent<$Diff<Config, { user?: ?User }>> =>
  function withUserHOC(props: $Diff<Config, { user?: ?User }>) {
    return (
      <UserContext.Consumer>
        {({ user }: UserContextType) => <Component {...props} user={user} />}
      </UserContext.Consumer>
    );
  };

/* @deprecated - use Context directly */
export const withSimpleToken = <Config: { simpleToken?: ?string }>(
  Component: React.AbstractComponent<Config>,
): React.AbstractComponent<$Diff<Config, { simpleToken?: ?string }>> =>
  function withSimpleTokenHOC(props: $Diff<Config, { simpleToken?: ?string }>) {
    return (
      <UserContext.Consumer>
        {({ simpleToken }: UserContextType) => (
          <Component {...props} simpleToken={simpleToken} />
        )}
      </UserContext.Consumer>
    );
  };

/* @deprecated - use Context directly */
export const withLoginToken = <Config: { loginToken?: ?string }>(
  Component: React.AbstractComponent<Config>,
): React.AbstractComponent<$Diff<Config, { loginToken?: ?string }>> =>
  function withLoginTokenHOC(props: $Diff<Config, { loginToken?: ?string }>) {
    return (
      <UserContext.Consumer>
        {({ loginToken }) => <Component {...props} loginToken={loginToken} />}
      </UserContext.Consumer>
    );
  };

/* @deprecated - use Context directly */
export const withKwAuthToken = <Config: { kwAuthToken?: ?string }>(
  Component: React.AbstractComponent<Config>,
): React.AbstractComponent<$Diff<Config, { kwAuthToken?: ?string }>> =>
  function withKwAuthTokenHOC(props: $Diff<Config, { kwAuthToken?: ?string }>) {
    return (
      <UserContext.Consumer>
        {({ kwAuthToken }: UserContextType) => (
          <Component {...props} kwAuthToken={kwAuthToken} />
        )}
      </UserContext.Consumer>
    );
  };

type TokenConfig = {
  simpleToken?: ?string,
  loginToken?: ?string,
  kwAuthToken?: ?string,
};

/* @deprecated - use Context directly */
export const withToken = <Config: TokenConfig>(
  Component: React.AbstractComponent<Config>,
): React.AbstractComponent<$Diff<Config, TokenConfig>> =>
  function withTokenHOC(props: $Diff<Config, TokenConfig>) {
    return (
      <UserContext.Consumer>
        {({ simpleToken, loginToken, kwAuthToken }: UserContextType) => (
          <Component
            {...props}
            simpleToken={simpleToken}
            loginToken={loginToken}
            kwAuthToken={kwAuthToken}
          />
        )}
      </UserContext.Consumer>
    );
  };