@tremorvideo/blink-cli/src/build-manifest/index.js

const path = require('path')
const chalk = require('chalk')
const fs = require('fs-extra')
const stripIndents = require('common-tags/lib/stripIndents')
const resolveVideos = require('../prepare/resolve-videos')
const getScriptsAndTitle = require('../prepare/get-scripts-and-title')
const getAnimatePublished = require('./get-animate-published')
const getComponentInfo = require('../util/get-component-info')
const getSnippetInfo = require('../util/get-snippet-info')
const blinkInfo = require('../info/index')
const Promise = require('bluebird')
const toml = require('toml')
const getHeaders = require('../util/get-headers')
const fsOpts = { encoding: 'utf8' }
const kitInfo = require('../util/get-kit-info')

const addContentLength = (format) => {
  const p = {}
  Object.keys(format).forEach((key) => {
    p[key] = getHeaders(format[key].uri).then((headers) => {
      format[key].contentLength = parseInt(headers['content-length'], 10)
      return format[key]
    })
  })
  return Promise.props(p)
}

module.exports = async ({ env, program, pkg }) => {
  try {
    const srcPath = path.join(program.cwd, './src')
    const distPath = path.join(program.cwd, './dist')
    const blinkPath = path.join(program.cwd, './blink.toml')
    const targetsPath = path.join(program.cwd, './package.json')
    const manifestPath = path.join(distPath, './manifest.json')
    const componentsPath = env.comp
    const [manifestBase, templateOutputs] = await Promise.all([
      fs.readFile(blinkPath, fsOpts)
        .catch((err) => {
          console.log(chalk.red('⚠️  Can\'t find blink.toml file.  You may be in the wrong directory'))
          return Promise.reject(err)
        })
        .then((body) => {
          if (!program.silent) console.log(`✅  Using ${chalk.underline(blinkPath)}`)
          return toml.parse(body)
        })
        .then((blink) => resolveVideos(blink))
        .then((blink) => {
          const p = {}
          Object.keys(blink.videos).forEach((key) => {
            const video = blink.videos[key]
            p[key] = Promise.props({
              hd: addContentLength(video.hd),
              sd: addContentLength(video.sd),
              playlists: Promise.resolve(video.playlists),
              originalKey: Promise.resolve(video.originalKey),
              outputs: Promise.resolve(video.outputs)
            })
          })
          return Promise.props(p).then((results) => {
            blink.videos = results
            return blink
          })
        }),
      fs.readdir(srcPath, fsOpts)
        .catch((err) => {
          console.log(chalk.red('⚠️  Can\'t find src directory.  You may be in the wrong directory'))
          return Promise.reject(err)
        })
        .then((filesList) => getAnimatePublished(srcPath, filesList))
        .catch((err) => {
          console.log(chalk.red('⚠️  You may not have published the creative yet'))
          return Promise.reject(err)
        })
        .then((files) => fs.readFile(path.join(srcPath, files.html), fsOpts))
        .then((template) => getScriptsAndTitle(template))
    ])
    const { title, width, height } = templateOutputs
    const blinkPkg = fs.readJsonSync(targetsPath, fsOpts)
    const blinkTargets = blinkPkg && blinkPkg.blink && blinkPkg.blink.targets
    const components = await getComponentInfo(path.join(srcPath, `${title}.js`), componentsPath, blinkTargets)
    const snippets = await getSnippetInfo(path.join(srcPath, `${title}.js`))
    const manifest = Object.assign({}, manifestBase, { targets: components.targets })
    const kitType = kitInfo(program, 'type')
    if (kitType !== 'display') {
      const blinkData = await blinkInfo({ program, pkg })
      if (blinkData.blinkCli.outdated) {
        console.log(stripIndents(chalk`
          {red ⚠️  Using blink-cli version ${pkg.version} (not up to date)}
          {red    Update to latest ({italic npm i -g @tremorvideo/blink-cli})}
        `))
      }
      if (blinkData.starterKits.outdated) {
        console.log(stripIndents(chalk`
          {red ⚠️  Using starter-kits version ${blinkData.starterKits.version} (not up to date)}
          {red    Update creative to latest (${pkg.starterKitVersion})}
        `))
      }
      if (blinkData.blinkCli.outdated || blinkData.starterKits.outdated) {
        console.log(chalk.red('Updating to latest versions before uploading is recommended!'))
      }
      manifest.blinkVersions = {
        blinkCli: blinkData.blinkCli.version,
        apl: (!env.withoutApl && blinkData.apl) ? blinkData.apl.version : 'none',
        blink: blinkData.blink.version,
        starterKit: blinkData.starterKits.version,
        blinkComponents: components.components,
        blinkSnippets: snippets
      }
    } else {
      manifest.blinkVersions = {
        blinkCli: null,
        apl: 'none',
        blink: null,
        blinkComponents: components.components,
        starterKit: null,
        blinkSnippets: snippets
      }
    }
    manifest.mediaFiles = [
      {
        id: title,
        delivery: 'progressive',
        type: 'application/javascript',
        bitrate: 466,
        width,
        height,
        maintainAspectRatio: true,
        scalable: true,
        apiFramework: 'VPAID'
      }
    ]
    manifest.refWidth = width
    manifest.refHeight = height
    manifest.general = manifestBase.general || {}
    manifest.general.bridgeId = title
    const tvEvents = manifestBase.tvEvents || manifestBase.tvCustomEvents
    const trackableEvents = tvEvents.trackableEvents || tvEvents.thirdPartyPixels || []
    const clickThruEvents = tvEvents.uri || []
    const designerEvents = (manifestBase.designerEvents && manifestBase.designerEvents.trackableEvents) || []
    const designerClickThrus = (manifestBase.designerEvents && manifestBase.designerEvents.uri) || []
    const allConfigurables = new Set(trackableEvents.concat(clickThruEvents, designerEvents, designerClickThrus, components.events))
    manifest.tvCustomEvents = [...allConfigurables].map((k) => {
      const parts = k.split('_')
      const configurable = {
        name: k,
        kind: parts[0] || '',
        context: parts[1] || '',
        args: parts.slice(2),
        uri: clickThruEvents.includes(k) || designerClickThrus.includes(k),
        thirdPartyPixels: trackableEvents.includes(k) || designerEvents.includes(k) || components.events.includes(k)
      }
      return configurable
    })
    if (kitType !== 'display') {
      // Custom Event for Third Party Tracking.  Needed by RML specifically.
      manifest.tvCustomEvents.unshift({
        name: 'Engagement_Third_Party',
        kind: 'Engagement',
        context: 'Third_Party',
        args: [],
        uri: false,
        thirdPartyPixels: true
      })
    }
    if (manifest.tvEvents) delete manifest.tvEvents
    if (manifest.designerEvents) delete manifest.designerEvents
    await fs.outputFile(manifestPath, JSON.stringify(manifest, null, 2), fsOpts)
    if (!program.silent) console.log('✅  Built manifest.json')
    return manifest
  } catch (err) {
    console.log(chalk.red('⚠️  manifest.json did NOT build'))
    return Promise.reject(err)
  }
}