var airbrake = new airbrakeJs.Client({
  projectId: 12345,
  projectKey: 'xxxxxxxxxxxx',
});

var airbrake = airbrakeMini({
  projectId: 12345,
  projectKey: 'xxxxxxxxxxxx',
});

try {
  // if throws if the document has no head tag
  const style = document.createElement('style');
  document.head.insertBefore(style);
} catch(err) {
  airbrake.notify(err);
  throw err;
}

const airbrake = airbrakeMini({
  projectId: 12345,
  projectKey: 'xxxxxxxxxxxxxxx',
  environment: getEnvironment(window.location.hostname)
})

airbrake.addFilter((notice) => {
  const { context } = notice;
  if (!context) return null;

  // filters out saved pages
  if (context.url && context.url.indexOf('file') === 0) {
    return null;
  }

  // filters out translation services and local env
  if (context.environment === 'unknown' ||
      context.environment === 'local') {
    return null;
  }

  return notice;
});

const envs = [
  { regexp: /\.tes\.com$/, name: 'production' },
  { regexp: /\.tes-dev\.com$/, name: 'development' },
  { regexp: /\.tes-stage\.com$/, name: 'staging' },
  { regexp: /\.tes-local\.com$/, name: 'local' }];

function getEnvironment (hostname) {
  // hostname is window.location.hostname
  for (let i = 0; i < envs.length; i++) {
    const { regexp, name } = envs[i];
    if (regexp.test(hostname)) return name;
  }
  return 'unknown';
}

class ErrorBoundary extends Component {
  state = { hasError: false };

  componentDidCatch (error, info) {
    this.setState({ hasError: true });
    this.props.onError(error, info);
  }

  render () {
    if (this.state.hasError) return <div>Try later</div>;
    return this.props.children;
  }
}

function getEBWrapper ({ onError }) {
  return (Component) => (props) => (
    <ErrorBoundary onError={onError}>
      <Component {...props} />
    </ErrorBoundary>);
}

const onError = (error, info) =>
  airbrake.notify({ error, params: { info })

const errorBoundaryWrapper = getEBWrapper({ onError });

render(errorBoundaryWrapper(App), mountPoint);

try {
  response = await fetch(endpoint, options);
} catch (e) {
  // normalises error messages
  throw new Error('endpoint fetch Error');
}

import deferUntilOnline from 'defer-until-online';

const deferUntil = deferUntilOnline({ timeout: 10000 });
 
const myfunc = deferUntil(() => {...});
 
const result = await myfunc(...);

import retry from 'async-deco/retry';

const retryDecorator = retry({ times: 10, interval: 1000 });

const myfunc = retryDecorator(() => {...})

{
  ...
  "scripts": {
    ...
    "build": "webpack && es-check es5 dist/js/*.js"
  }
}