get preact files into root

src/computes.js

@@ -0,0 +1,284 @@
+import {
+	deferred
+} from './deferred';
+import {
+	addInfiniteLoopProtection
+} from './utils';
+import {
+	HtmlModes,
+	CssModes,
+	JsModes
+} from './codeModes';
+
+const esprima = require('esprima');
+
+// computeHtml, computeCss & computeJs evaluate the final code according
+// to whatever mode is selected and resolve the returned promise with the code.
+export function computeHtml(code, mode) {
+	var d = deferred();
+	if (mode === HtmlModes.HTML) {
+		d.resolve({
+			code
+		});
+	} else if (mode === HtmlModes.MARKDOWN) {
+		d.resolve(window.marked ? {
+			code: marked(code)
+		} : {
+			code
+		});
+	} else if (mode === HtmlModes.JADE) {
+		d.resolve(window.jade ? {
+			code: jade.render(code)
+		} : {
+			code
+		});
+	}
+
+	return d.promise;
+}
+export function computeCss(code, mode, settings) {
+	var d = deferred();
+	var errors;
+
+	if (mode === CssModes.CSS) {
+		d.resolve({
+			code
+		});
+	} else if (mode === CssModes.SCSS || mode === CssModes.SASS) {
+		if (window.sass && code) {
+			window.sass.compile(
+				code, {
+					indentedSyntax: mode === CssModes.SASS
+				},
+				function (result) {
+					// Something was wrong
+					if (result.line && result.message) {
+						errors = {
+							lang: 'css',
+							data: [{
+								lineNumber: result.line - 1,
+								message: result.message
+							}]
+						};
+					}
+					d.resolve({
+						code: result.text,
+						errors
+					});
+				}
+			);
+		} else {
+			d.resolve({
+				code
+			});
+		}
+	} else if (mode === CssModes.LESS) {
+		less.render(code).then(
+			function (result) {
+				d.resolve({
+					code: result.css
+				});
+			},
+			function (error) {
+				errors = {
+					lang: 'css',
+					data: [{
+						lineNumber: error.line,
+						message: error.message
+					}]
+				};
+				d.resolve({
+					code: '',
+					errors
+				})
+			}
+		);
+	} else if (mode === CssModes.STYLUS) {
+		stylus(code).render(function (error, result) {
+			if (error) {
+				window.err = error;
+				// Last line of message is the actual message
+				var tempArr = error.message.split('\n');
+				tempArr.pop(); // This is empty string in the end
+				errors = {
+					lang: 'css',
+					data: [{
+						lineNumber: +error.message.match(/stylus:(\d+):/)[1] - 298,
+						message: tempArr.pop()
+					}]
+				};
+			}
+			d.resolve({
+				code: result,
+				errors
+			});
+		});
+	} else if (mode === CssModes.ACSS) {
+		if (!window.atomizer) {
+			d.resolve({
+				code: ''
+			});
+		} else {
+			const html = code;
+			const foundClasses = atomizer.findClassNames(html);
+			var finalConfig;
+			try {
+				finalConfig = atomizer.getConfig(
+					foundClasses,
+					JSON.parse(settings.acssConfig)
+				);
+			} catch (e) {
+				finalConfig = atomizer.getConfig(foundClasses, {});
+			}
+			const acss = atomizer.getCss(finalConfig);
+			d.resolve({
+				code: acss
+			});
+		}
+	}
+
+	return d.promise;
+}
+
+export function computeJs(code, mode, shouldPreventInfiniteLoops, infiniteLoopTimeout) {
+	var d = deferred();
+	var errors;
+
+	if (!code) {
+		d.resolve('');
+		return d.promise;
+	}
+
+	if (mode === JsModes.JS) {
+		try {
+			esprima.parse(code, {
+				tolerant: true
+			});
+		} catch (e) {
+			errors = {
+				lang: 'js',
+				data: [{
+					lineNumber: e.lineNumber - 1,
+					message: e.description
+				}]
+			};
+		} finally {
+			if (shouldPreventInfiniteLoops !== false) {
+				// If errors are found in last parse, we don't run infinite loop
+				// protection otherwise it will again throw error.
+				code = errors ? code : addInfiniteLoopProtection(code, {
+					timeout: infiniteLoopTimeout
+				});
+			}
+
+			d.resolve({
+				code,
+				errors
+			});
+		}
+	} else if (mode === JsModes.COFFEESCRIPT) {
+		if (!window.CoffeeScript) {
+			d.resolve('');
+			return d.promise;
+		}
+		try {
+			code = CoffeeScript.compile(code, {
+				bare: true
+			});
+		} catch (e) {
+			errors = {
+				lang: 'js',
+				data: [{
+					lineNumber: e.location.first_line,
+					message: e.message
+				}]
+			};
+		} finally {
+			if (shouldPreventInfiniteLoops !== false) {
+				code = errors ? code : addInfiniteLoopProtection(code, {
+					timeout: infiniteLoopTimeout
+				});
+			}
+			d.resolve({
+				code,
+				errors
+			});
+		}
+	} else if (mode === JsModes.ES6) {
+		if (!window.Babel) {
+			d.resolve('');
+			return d.promise;
+		}
+		try {
+			esprima.parse(code, {
+				tolerant: true,
+				jsx: true
+			});
+		} catch (e) {
+			errors = {
+				lang: 'js',
+				data: [{
+					lineNumber: e.lineNumber - 1,
+					message: e.description
+				}]
+			};
+		} finally {
+			code = Babel.transform(code, {
+				presets: ['latest', 'stage-2', 'react']
+			}).code;
+			if (shouldPreventInfiniteLoops !== false) {
+				code = errors ? code : addInfiniteLoopProtection(code, {
+					timeout: infiniteLoopTimeout
+				});
+			}
+			d.resolve({
+				code,
+				errors
+			});
+		}
+	} else if (mode === JsModes.TS) {
+		try {
+			if (!window.ts) {
+				d.resolve({
+					code: ''
+				});
+				return d.promise;
+			}
+			code = ts.transpileModule(code, {
+				reportDiagnostics: true,
+				compilerOptions: {
+					noEmitOnError: true,
+					diagnostics: true,
+					module: ts.ModuleKind.ES2015
+				}
+			});
+			if (code.diagnostics.length) {
+				/* eslint-disable no-throw-literal */
+				errors = {
+					lang: 'js',
+					data: [{
+						message: code.diagnostics[0].messageText,
+						lineNumber: ts.getLineOfLocalPosition(
+							code.diagnostics[0].file,
+							code.diagnostics[0].start
+						) - 1
+					}]
+				};
+			}
+			code = code.outputText;
+			if (shouldPreventInfiniteLoops !== false && !errors) {
+				code = addInfiniteLoopProtection(code, {
+					timeout: infiniteLoopTimeout
+				});
+			}
+			d.resolve({
+				code,
+				errors
+			});
+		} catch (e) {
+
+		}
+	}
+
+	return d.promise;
+}