const fs = require('fs');
|
const UglifyJS = require("uglify-js");
|
const packageFile = require("../package.json");
|
|
const buildFolder = 'build/player/';
|
const rootFolder = 'player/';
|
const bm_version = packageFile.version;
|
const defaultBuilds = [ 'canvas_worker', 'lottie_worker']
|
|
const scripts = [
|
|
]
|
|
function wrapScriptWithModule(code, build) {
|
return new Promise((resolve, reject)=>{
|
try {
|
// Wrapping with module
|
let moduleFileName = 'worker_wrapper';
|
let wrappedCode = fs.readFileSync(`${rootFolder}js/${moduleFileName}.js`, "utf8");
|
wrappedCode = wrappedCode.replace('/* <%= contents %> */',code);
|
wrappedCode = wrappedCode.replace('[[BM_VERSION]]',bm_version);
|
resolve(wrappedCode);
|
} catch(err) {
|
reject(err);
|
}
|
});
|
}
|
|
function uglifyCode(code) {
|
return new Promise((resolve, reject)=>{
|
try {
|
const result = UglifyJS.minify(code, {
|
output:
|
{
|
ascii_only:true
|
},
|
toplevel:true,
|
mangle: {
|
reserved: ['lottie']
|
}
|
});
|
if (result.error) {
|
reject(result.error)
|
} else {
|
resolve(result.code)
|
}
|
} catch(err) {
|
reject(err)
|
}
|
})
|
}
|
|
async function modularizeCode(code, build) {
|
const globalScope = (build =='canvas_worker' || build =='lottie_worker') ? 'self' : 'window'
|
return `(typeof navigator !== "undefined") && (function(root, factory) {
|
if (typeof define === "function" && define.amd) {
|
define(function() {
|
return factory(root);
|
});
|
} else if (typeof module === "object" && module.exports) {
|
module.exports = factory(root);
|
} else {
|
root.lottie = factory(root);
|
root.bodymovin = root.lottie;
|
}
|
}((${globalScope} || {}), function(window) {
|
${code}
|
return lottie;
|
}));`
|
}
|
|
async function getCode() {
|
try {
|
let scriptsString = '';
|
scriptsString += fs.readFileSync(`${buildFolder}lottie.js`, {encoding: 'utf8'});
|
scriptsString += '\r\n';
|
return scriptsString;
|
} catch(err) {
|
throw err;
|
}
|
}
|
|
async function buildVersion(version) {
|
try {
|
const code = await getCode(version.build)
|
const wrappedCode = await wrapScriptWithModule(code, version.build)
|
const processedCode = await version.process(wrappedCode)
|
const modularizedCode = await modularizeCode(processedCode, version.build)
|
const saved = await save(modularizedCode, version.fileName)
|
return saved
|
} catch (error) {
|
console.log(error);
|
return null;
|
}
|
}
|
|
function save(code, fileName) {
|
return new Promise((resolve, reject)=> {
|
fs.writeFile(`${buildFolder}${fileName}`, code, (err) => {
|
if (err) {
|
reject(err)
|
} else {
|
resolve(true)
|
}
|
});
|
})
|
}
|
|
function noop(code) {
|
return Promise.resolve(code)
|
}
|
|
function buildVersions() {
|
return new Promise((resolve, reject) => {
|
let versions = [
|
{
|
fileName: 'lottie_canvas_worker.js',
|
build: 'canvas_worker',
|
process: noop
|
},
|
{
|
fileName: 'lottie_canvas_worker.min.js',
|
build: 'canvas_worker',
|
process: uglifyCode
|
},
|
{
|
fileName: 'lottie_worker.js',
|
build: 'lottie_worker',
|
process: noop
|
},
|
{
|
fileName: 'lottie_worker.min.js',
|
build: 'lottie_worker',
|
process: uglifyCode
|
}
|
];
|
|
const buildProcesses = versions.map((version)=>{
|
return buildVersion(version)
|
})
|
Promise.all(buildProcesses)
|
.then(() => {
|
resolve('Build Process Ended')
|
})
|
.catch((err)=>{
|
reject(err)
|
})
|
})
|
}
|
|
function handleError(err) {
|
console.log(err);
|
}
|
|
async function build() {
|
try {
|
const result = await buildVersions();
|
|
} catch(err) {
|
handleError(err);
|
}
|
}
|
|
build()
|
