psd2bmf/dist/utils.js

Convert the psd to bmfont.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isString = isString;
exports.isObject = isObject;
exports.isArray = isArray;
exports.merge = merge;
exports.readFile = readFile;
exports.writeFile = writeFile;
exports.readBmfTemp = readBmfTemp;
exports.readPng = readPng;
exports.writePng = writePng;
exports.createPng = createPng;
exports.parseRecognizeArgs = parseRecognizeArgs;
exports.mergeRecognizeArgs = mergeRecognizeArgs;
exports.isExist = isExist;
exports.mustExist = mustExist;

var _path = _interopRequireDefault(require("path"));

var _fsExtra = _interopRequireDefault(require("fs-extra"));

var _pngjs = require("pngjs");

var _const = require("./const");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function isString(any) {
  return typeof any === 'string';
}

function isObject(any) {
  return typeof any === 'object';
}

function isArray(any) {
  return Array.isArray(any);
}

function merge(src, opt) {
  if (opt && (isObject(opt) || isArray(opt))) {
    Object.keys(opt).forEach(attr => {
      if (attr in src) {
        src[attr] = opt[attr];
      }
    });
  }

  return src;
}

async function readFile(filePath, option) {
  return new Promise(resolve => {
    _fsExtra.default.exists(filePath, exists => {
      if (exists) {
        _fsExtra.default.readFile(filePath, option, (err, data) => {
          resolve(err ? null : data);
        });
      } else {
        resolve(null);
      }
    });
  });
}

async function writeFile(filePath, data, option) {
  return new Promise((resolve, reject) => {
    _fsExtra.default.outputFile(filePath, data, option, err => {
      err ? reject() : resolve();
    });
  });
}

let bmfTemp = null;

async function readBmfTemp() {
  if (bmfTemp === null) {
    bmfTemp = await readFile(_const.BMF_FNT_TEMP, _const.ENCODING);
  }

  return bmfTemp;
}

async function readPng(pngPath) {
  return new Promise(resolve => {
    _fsExtra.default.exists(pngPath, exists => {
      if (exists) {
        _fsExtra.default.createReadStream(pngPath).pipe(createPng(undefined, undefined)).on('parsed', function () {
          resolve(this);
        }).on('error', function () {
          resolve(null);
        });
      } else {
        resolve(null);
      }
    });
  });
}

async function writePng(pngPath, pngData) {
  return new Promise((resolve, reject) => {
    const dir = _path.default.parse(pngPath).dir;

    _fsExtra.default.ensureDir(dir, err => {
      if (err) {
        reject();
      } else {
        pngData.pack().pipe(_fsExtra.default.createWriteStream(pngPath)).on('close', resolve).on('error', reject);
      }
    });
  });
}

function createPng(width, height) {
  return new _pngjs.PNG({
    width: width,
    height: height // DeflateLevel: 0,
    // filterType: 4

  });
}

function parseRecognizeArgs(argsStr) {
  let obj = {};

  if (argsStr && isString(argsStr)) {
    if (/\w+=.+&?/.test(argsStr)) {
      let args = argsStr.split('&');

      for (let i = args.length - 1; i >= 0; i--) {
        let strArr = args[i].split('=');
        let value = strArr[1];
        obj[strArr[0]] = isNaN(Number(value)) ? value : parseInt(value, 10);
      }
    } else {
      console.warn('The recognize args incorrect.');
    }
  }

  return obj;
}

function mergeRecognizeArgs(src, argsStr) {
  return merge(src, parseRecognizeArgs(argsStr));
}

function isExist(filePath, extName) {
  const info = _path.default.parse(filePath);

  if (info.ext === extName) return _fsExtra.default.existsSync(filePath);
  return false;
}

function mustExist(filePath, extName) {
  const info = _path.default.parse(filePath);

  if (info.ext === extName) {
    if (_fsExtra.default.existsSync(filePath)) return filePath;
    throw new Error('The file does not exist:' + filePath);
  } else {
    throw new Error(`This is not a ${extName} file!`);
  }
}