ember-svg-jar/lib/viewer-assets-builder.js

'use strict';

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var path = require('path');
var fs = require('fs');
var _ = require('lodash');
var CachingWriter = require('broccoli-caching-writer');
var mkdirp = require('mkdirp');
var validateAssets = require('./validate-assets');
var svgDataFor = require('./utils/svg-data-for');

var _require = require('./utils/general');

var filePathsOnlyFor = _require.filePathsOnlyFor;
var relativePathFor = _require.relativePathFor;
var makeAssetId = _require.makeAssetId;


function svgSizeFor(svgAttrs) {
  var _split = (svgAttrs.viewBox || '').split(/\s+/);

  var _split2 = _slicedToArray(_split, 4);

  var vbWidth = _split2[2];
  var vgHeight = _split2[3];


  return {
    width: parseFloat(svgAttrs.width || vbWidth) || null,
    height: parseFloat(svgAttrs.height || vgHeight) || null
  };
}

function stringSizeInKb(string) {
  var bytes = Buffer.byteLength(string, 'utf8');
  return parseFloat((bytes / 1024).toFixed(2));
}

/**
  Required options:
    idGen
    idGenOpts
    copypastaGen
    stripPath
    strategy
    outputFile

  Optional:
    ui
    annotation
*/
function ViewerAssetsBuilder(inputNode) {
  var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  CachingWriter.call(this, [inputNode], {
    name: 'ViewerAssetsBuilder',
    annotation: options.annotation
  });

  this.ui = options.ui;
  this.options = {
    idGen: _.partial(options.idGen, _, options.idGenOpts),
    copypastaGen: options.copypastaGen,
    stripPath: options.stripPath,
    strategy: options.strategy,
    outputFile: options.outputFile
  };
}

ViewerAssetsBuilder.prototype = Object.create(CachingWriter.prototype);
ViewerAssetsBuilder.prototype.constructor = ViewerAssetsBuilder;

ViewerAssetsBuilder.prototype.build = function () {
  var _options = this.options;
  var idGen = _options.idGen;
  var stripPath = _options.stripPath;
  var strategy = _options.strategy;

  var inputPath = this.inputPaths[0];
  var toRelative = _.partial(relativePathFor, _, inputPath);
  var idFor = _.partial(makeAssetId, _, stripPath, idGen);
  var assets = this.getAssets(filePathsOnlyFor(this.listFiles()), toRelative, idFor);

  if (this.ui) {
    validateAssets(assets, strategy, this.ui);
  }

  var viewerItems = this.viewerItemsFor(assets, inputPath, this.options);
  var outputFilePath = path.join(this.outputPath, this.options.outputFile);
  mkdirp.sync(path.dirname(outputFilePath));
  fs.writeFileSync(outputFilePath, JSON.stringify(viewerItems));
};

ViewerAssetsBuilder.prototype.getAssets = function (filePaths, toRelative, idFor) {
  return _(filePaths).filter(function (filePath) {
    return filePath.indexOf('__original__') === -1;
  }).map(function (filePath) {
    return [filePath, fs.readFileSync(filePath, 'UTF-8')];
  }).filter(function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2);

    var svgContent = _ref2[1];
    return !!svgContent;
  }).map(function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 2);

    var filePath = _ref4[0];
    var svgContent = _ref4[1];

    var relativePath = toRelative(filePath);

    return {
      id: idFor(relativePath),
      svgData: svgDataFor(svgContent),
      optimizedSvg: svgContent,
      relativePath: relativePath
    };
  }).value();
};

ViewerAssetsBuilder.prototype.viewerItemsFor = function (assets, inputPath, options) {
  var strategy = options.strategy;
  var copypastaGen = options.copypastaGen;

  var originalPath = path.join(inputPath, '__original__');

  return assets.map(function (asset) {
    var _svgSizeFor = svgSizeFor(asset.svgData.attrs);

    var width = _svgSizeFor.width;
    var height = _svgSizeFor.height;

    var originalFilePath = path.join(originalPath, asset.relativePath);
    var originalSvg = fs.readFileSync(originalFilePath, 'UTF-8');

    return {
      svg: asset.svgData,
      originalSvg: originalSvg,
      width: width,
      height: height,
      fileName: path.basename(asset.relativePath),
      fileDir: path.dirname(asset.relativePath).replace('.', '/'),
      fileSize: stringSizeInKb(originalSvg) + ' KB',
      optimizedFileSize: stringSizeInKb(asset.optimizedSvg) + ' KB',
      baseSize: _.isNull(height) ? 'unknown' : height + 'px',
      fullBaseSize: width + 'x' + height + 'px',
      copypasta: copypastaGen(asset.id),
      strategy: strategy
    };
  });
};

module.exports = ViewerAssetsBuilder;