How to use the serve-favicon function in serve-favicon

const app = express(feathers());
// !code: use_start // !end

// Load app configuration
app.configure(configuration());
// ! code: init_config
app.set('generatorSpecs', generatorSpecs);
// !end

// Enable security, CORS, compression, favicon and body parsing
app.use(helmet());
app.use(cors());
app.use(compress());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(favicon(path.join(app.get('public'), 'favicon.ico')));
// Host the public folder
app.use('/', express.static(app.get('public')));
// !code: use_end // !end

// Set up Plugins and providers
// !code: config_start // !end
app.configure(express.rest());
app.configure(socketio());

// Configure database adapters
app.configure(sequelize);

// Configure other middleware (see `middleware/index.ts`)
app.configure(middleware);
// Configure authentication (see `authentication.ts`)
app.configure(authentication);

export default () => {
  const app = express()
  const server = http.createServer(app)
  const io = socketio(server, config.socketio)

  mongoose.connect(config.db)
  if (!fs.existsSync(path.join(__dirname, '..', 'vrs.info'))) {
    modelInit().then(databaseInit).then(() => console.log(`Finished initialization.`))
  }

  // tools
  app.use(cookieParser())
  app.use(expressSession(config.session))
  app.use(compression())
  app.use(cors({origin: ['*.shud.in', 'localhost:*', '127.0.0.1:*']}))
  app.use(serveFavicon(path.join(__dirname, '..', 'public', 'static', 'images', 'favicon.ico')))
  app.use(passport.initialize())
  app.use(passport.session())

  // GraphQL
  app.use('/api', expressGraphQL({
    schema,
    // turn on graphiql for debugging if under dev mode
    graphiql: global.__is_dev
  }))

  // authenticate
  passport.serializeUser((user, done) => done(null, user))
  passport.deserializeUser((user, done) => done(null, user))
  passport.use(new TwitterStrategy({
      consumerKey: config.TWITTER_CONSUMER_KEY,
      consumerSecret: config.TWITTER_CONSUMER_SECRET,

res.setHeader("Content-Type", "application/manifest+json");
  // No cache header
  res.setHeader("Cache-Control", "private, no-cache, no-store, must-revalidate");
  res.setHeader("Expires", "-1");
  res.setHeader("Pragma", "no-cache");
  
  return res.send(JSON.stringify(pwa));
});

/**
 * Try to get the public dir
 */
try {
  const faviconPath = path.join(currentDir, publicDirName, "favicon.ico");
  if (path.resolve(faviconPath)) {
    app.use(serveFavicon(faviconPath));
  }
} catch (ex) {
  // eslint-disable-next-line
  console.log(`Please add favicon @ ${publicDirName}/favicon.ico for improved performance.`);
}

/**
 * Send global data to user, as we do not want to send it via
 * window object
 */
app.get("/_globals", infiniteCache(), (req, res) => {
  // Never ever cache this request
  const {assets} = req;
  const allCss = extractFilesFromAssets(assets, ".css");
  const allJs = extractFilesFromAssets(assets, ".js");

import AltIsomorphicElement from './src/components/AltIsomorphicElement'
import Iso from 'iso'
import bodyParser from 'body-parser'
import cookieParser from 'cookie-parser'
import favicon from 'serve-favicon'
import path from 'path'

let port = 8080
let ip = '127.0.0.1'
let app = express()

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use('/public', express.static(path.join(__dirname, 'public')))
app.use(favicon(__dirname + '/public/favicon.ico'));

app.set('views', path.join(__dirname, 'templates'));
app.set('view engine', 'jade')


/* Simulate an asynchronous event to retrieve products from storage. */
function getProductsFromServer(cb) {
  setTimeout(function () {

    var mockData = [
      {name: 'Football', category: 'Sporting Goods', price: '$49.99', stocked: true, visible: true},
      {name: 'Basketball', category: 'Sporting Goods', price: '$29.99', stocked: false, visible: true},
      {name: 'iPhone 5', category: 'Electronics', price: '$399.99', stocked: false, visible: true},
      {name: 'Nexus 7', category: 'Electronics', price: '$199.99', stocked: true, visible: true}
    ];

var app = express()

app.set('trust proxy', 1)

app.use(session({
  secret: 'autodeskforge',
  cookie: {
    secure: (process.env.NODE_ENV === 'production'), //requires https
    maxAge: 1000 * 60 * 60 * 24 // 24h session
  },
  resave: false,
  saveUninitialized: true
}))

app.use('/resources', express.static(__dirname + '/../../resources'))
app.use(favicon(__dirname + '/../../resources/img/forge.png'))
app.use('/', express.static(__dirname + '/../../dist/'))
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())
app.use(cookieParser())
app.use(helmet())

/////////////////////////////////////////////////////////////////////
// Routes setup
//
/////////////////////////////////////////////////////////////////////
app.use('/api/forge', ForgeAPI())

/////////////////////////////////////////////////////////////////////
//
//
/////////////////////////////////////////////////////////////////////

import config from './config';
import configureStore from './store/configureStore';
import Html from './helpers/Html';
import getRoutes from './routes';
import waitAll from './sagas/waitAll';
import { Root } from 'containers';

const pretty = new PrettyError();
const app = new Express();
const server = new http.Server(app);

// disable `X-Powered-By` HTTP header
app.disable('x-powered-by');

app.use(compression());
app.use(favicon(path.join(__dirname, '..', 'static', 'favicon.ico')));
app.use(Express.static(path.join(__dirname, '..', 'static')));

// Proxy to API
app.use('/api', proxy(config.apiBaseUrl, {
  // eslint-disable-next-line
  forwardPath: (req, res) => url.parse(req.url).path
}));

app.use((req, res) => {
  if (__DEVELOPMENT__) {
    webpackIsomorphicTools.refresh();
  }

  const memoryHistory = createMemoryHistory();
  const store = configureStore();
  const allRoutes = getRoutes(store);

// If not exits client, when set internal default
  if (!fs.existsSync(config.client)) {
    
    client = `${config.base}/views/default`;
    file = config.mode;

    if (config.io.example) {
      app.use('/socket', express.static(`${client}/socket.html`));
      app.use('/token', express.static(`${client}/token.html`));
    }

  }

  app.use(express.static(client));
  app.use(favicon(path.join(client, 'favicon.ico')));

  // Folder client
  app.get('/*', (req, res) => {
    res.sendFile(`${client}/${file}.html`);
  });

  // ADD PATHS HERE!
  // Examples

  // app.use('/bower_components', express.static(`${config.root}/bower_components`));}
  
  // app.get('/:url(admin)/*', (req, res) => {
  //     res.sendFile(`${config.client2}/index.html`);
  // });

}

import rateLimits from 'middlewares/limits';
import refererAndOrigin from 'middlewares/referer-origin';
import routes from 'routes';
import security from 'middlewares/security';
import session from 'middlewares/session';

const PUBLIC_FOLDER = path.join(__dirname, 'public');
let app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
// global variables
app.locals.moment = moment;
// favicon
app.use(favicon(path.join(PUBLIC_FOLDER, 'favicon.ico')));
// logger
app.use(logger);
// gzip, brotli compression; pre-compressed-assets
compression(app, PUBLIC_FOLDER);
// assets folder and caching
assets(app, PUBLIC_FOLDER);
// assets locals
app.use(assetLocals);
// JSON body
app.use(bodyParser.json());
// application/x-www-form-urlencoded body
app.use(bodyParser.urlencoded({ extended: false }));
// caching
caching(app);
// security - helmet
security(app);

import { createStore, WP } from './store'
import config from './config'
import routes from './routes'

if (!config.port) {
  console.error('==> ERROR: No port environment variable')
  console.error('==> ERROR: Exiting...')
  process.exit()
}

const app = new Express()
const pretty = new PrettyError()
const server = new http.Server(app)

app.use(compression())
app.use(favicon(path.join(__dirname, '../static/favicon.ico')))
app.use(Express.static(path.join(__dirname, '..', 'static')))

app.use((req, res) => {
  if (__DEVELOPMENT__) {
    global.webpackIsomorphicTools.refresh()
  }

  const location = req.originalUrl
  const history = useRouterHistory(createMemoryHistory)({})
  const store = createStore(history, {})

  syncHistoryWithStore(history, store)
  history.replace(req.originalUrl)

  pify(match, { multiArgs: true })({ history, routes, location })
    .then((result) => {

import express from 'express'
import path from 'path'
import favicon from 'serve-favicon'
import routes from './routes'
import * as React from 'react'
import Root from './containers/Root'
import { renderToString } from 'react-dom/server'
import { match, createMemoryHistory } from 'react-router'
import configureStore from './store/configureStore'
import rootSaga from './sagas'


var app = express()
var port = 3000

app.use(favicon(path.join(__dirname, 'favicon.ico')))
var compiler = webpack(config)
app.use(webpackDevMiddleware(compiler, { noInfo: true, publicPath: config.output.publicPath }))
app.use(webpackHotMiddleware(compiler))

const layout = (body, initialState) => (`
  
  
  
    
    <title>Redux-saga real-world universal example</title>
  
  
    <div id="root"><div>${body}</div></div>