@lumen5/lottie-web 5.14.0

package/tasks/build_worker.js

@@ -0,0 +1,164 @@
+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()

package/tasks/watch.js

@@ -0,0 +1,34 @@
+var childProcess = require('child_process');
+var watch = require('watch')
+
+function runScript(scriptPath, processArguments, callback) {
+
+    // keep track of whether callback has been invoked to prevent multiple invocations
+    var invoked = false;
+
+    var process = childProcess.fork(scriptPath, processArguments);
+
+    // listen for errors as they may prevent the exit event from firing
+    process.on('error', function (err) {
+        if (invoked) return;
+        invoked = true;
+        callback(err);
+    });
+
+    // execute the callback once the process has finished running
+    process.on('exit', function (code) {
+        if (invoked) return;
+        invoked = true;
+        var err = code === 0 ? null : new Error('exit code ' + code);
+        callback(err);
+    });
+
+}
+
+
+  watch.watchTree(`${__dirname}\\..\\player\\js\\`, function (f, curr, prev) {
+    runScript(`${__dirname}\\build.js`, ["reduced"], function (err) {
+        if (err) throw err;
+        console.log('finished running some-script.js');
+    });
+  })