alchemymvc 1.4.0-alpha.2 → 1.4.0-alpha.3

package/lib/app/assets/stylesheets/{alchemy-info.less → alchemy-info.scss}

@@ -1,3 +1,5 @@
+@use "alchemy";
+
 html {
 	font-family: sans-serif;
 	text-size-adjust: 100%;

package/lib/app/conduit/loopback_conduit.js

@@ -89,7 +89,7 @@ LoopConduit.setMethod(function copyParentProperties(conduit) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.3
- * @version  1.3.0
+ * @version  1.4.0
  *
  * @param    {Object}      options
  * @param    {Function}    callback
@@ -108,17 +108,20 @@ LoopConduit.setMethod(function setOptions(options, callback) {
 	options = JSON.clone(options);
 
 	for (key in options) {
-		let set_method = false;
+
+		// Keep track if a request method has been set
+		let got_method = false;
 
 		info = Classes.Develry.Request.getMethodInfo(key);
 
 		if (info && options[key]) {
 
-			if (info.method == 'get' && set_method) {
-				// Ignore
+			if (info.method == 'get' && got_method) {
+				// If a request method has already been set,
+				// do not let `get` options overwrite it!
 			} else {
 				this.method = key;
-				set_method = true;
+				got_method = true;
 			}
 
 			if (info.has_body && typeof options[key] == 'object') {
@@ -131,6 +134,8 @@ LoopConduit.setMethod(function setOptions(options, callback) {
 		this.method = options.method;
 	}
 
+	let route_params = options.params;
+
 	if (options.name) {
 		// @TODO: what about path sections?
 		route = this.getRouteByName(options.name);
@@ -147,7 +152,7 @@ LoopConduit.setMethod(function setOptions(options, callback) {
 
 		// @WARNING: It's best to just generate the URL
 		// and let it parse all the information that way
-		options.href = this.routeUrl(options.name, options.params, {extra_get_parameters: false});
+		options.href = this.routeUrl(options.name, route_params, {extra_get_parameters: false});
 	}
 
 	if (!this.method) {
@@ -158,6 +163,10 @@ LoopConduit.setMethod(function setOptions(options, callback) {
 
 		this.original_url = RURL.parse(options.href);
 
+		if (options.get && typeof options.get == 'object') {
+			this.original_url.addQuery(options.get);
+		}
+
 		this.url = this.original_url;
 		this.original_path = this.url.path;
 		this.original_pathname = this.url.pathname;
@@ -169,14 +178,20 @@ LoopConduit.setMethod(function setOptions(options, callback) {
 		this.parseSection();
 
 		promise = this.parseRoute();
+	} else if (options.get && typeof options.get == 'object') {
+		if (!this.params) {
+			this.params = {};
+		}
+
+		Object.assign(this.params, options.get);
 	}
 
 	if (options.body) {
 		this.body = options.body;
 	}
 
-	if (options.params) {
-		this.setRouteParameters(options.params);
+	if (route_params) {
+		this.setRouteParameters(route_params);
 	}
 
 	if (options.arguments) {

package/lib/app/helper/enum_values.js

@@ -40,7 +40,7 @@ EnumMap.setMethod(function get(name) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.2.1
- * @version  1.2.1
+ * @version  1.4.0
  *
  * @param    {string}   name
  * @param    {*}        value
@@ -65,18 +65,37 @@ EnumMap.setMethod(function set(name, value) {
 			name  : value,
 			title : value,
 		};
-	} else if (typeof value == 'function') {
-		result = {
-			name  : value.name,
-			title : value.title,
-		};
 	} else {
-		result = {
-			name  : value.name,
-			title : value.title || value.name,
-		};
+		if (typeof value == 'function') {
+			result = {
+				name  : value.name,
+				title : value.title,
+			};
+		} else {
+			result = {
+				name  : value.name,
+				title : value.title || value.name,
+			};
+
+			if (value.icon) {
+				result.icon = value.icon;
+			}
+
+			if (value.color) {
+				result.color = value.color;
+			}
+
+			if (value.text_color) {
+				result.text_color = value.text_color;
+			}
+		}
+
+		if (value.enum_info) {
+			Object.assign(result, value.enum_info);
+		}
 	}
 
+	result.number = this.local.size + 1;
 	result.value = value;
 	result.is_enumified = true;
 

package/lib/app/helper/router_helper.js

@@ -112,7 +112,7 @@ Router.setMethod(function isLocalUrl(url) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.3.1
+ * @version  1.4.0
  *
  * @param    {Element}   element    The element to apply to
  * @param    {string}    name       The route name
@@ -225,6 +225,8 @@ Router.setMethod(function applyDirective(element, name, options) {
 		disable_ajax = true;
 	}
 
+	let method_attribute = false;
+
 	if (element.role == 'link') {
 		attribute_name = 'href';
 	} else {
@@ -232,6 +234,7 @@ Router.setMethod(function applyDirective(element, name, options) {
 		switch (element.nodeName) {
 			case 'FORM':
 				attribute_name = 'action';
+				method_attribute = 'method'; 
 				break;
 
 			case 'AREA':
@@ -260,6 +263,10 @@ Router.setMethod(function applyDirective(element, name, options) {
 		}
 	}
 
+	if (method_attribute && config.methods?.[0]) {
+		element.setAttribute(method_attribute, config.methods[0]);
+	}
+
 	if (disable_ajax) {
 		element.setAttribute('data-he-link', 'false');
 	}
@@ -384,19 +391,13 @@ Router.setMethod(function routeConfig(name, socket_route) {
  */
 Router.setMethod(function routeUrl(name, parameters, options) {
 
-	var base_url,
-	    locales,
-	    config,
-	    url,
-	    key,
-	    i;
-
 	if (!options) {
 		options = {};
 	}
 
-	url = '';
-	config = options.config || this.routeConfig(name);
+	let locales,
+	    config = options.config || this.routeConfig(name),
+	    url = '';
 
 	if (options.locale || options.prefix) {
 		locales = [options.prefix || options.locale];
@@ -417,11 +418,15 @@ Router.setMethod(function routeUrl(name, parameters, options) {
 			// (in case it's a special parameters object, like a Document)
 			parameters = Object.create(parameters);
 		}
+	} else {
+		parameters = {};
 	}
 
 	let chosen_prefix;
 
 	if (config != null) {
+		let i;
+
 		for (i = 0; i < locales.length; i++) {
 			if (config.paths && config.paths[locales[i]]) {
 				chosen_prefix = locales[i];
@@ -435,7 +440,7 @@ Router.setMethod(function routeUrl(name, parameters, options) {
 		}
 
 		if (!url && config.paths) {
-			key = Object.keys(config.paths).first();
+			let key = Object.keys(config.paths).first();
 
 			if (key) {
 				url = '/' + key + config.paths[key];
@@ -520,6 +525,9 @@ Router.setMethod(function routeUrl(name, parameters, options) {
 	}
 
 	if (options.full || options.absolute) {
+
+		let base_url;
+
 		if (this.view) {
 			base_url = this.view.internal('url');
 		}

package/lib/app/helper_field/enum_field.js

@@ -83,4 +83,17 @@ Enum.setMethod(function getClientConfigOptions(wm) {
 	let options = JSON.clone(this.options, 'toHawkejs', wm);
 
 	return options;
+});
+
+/**
+ * Get the configuration entry for the given value
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @return   {Object}
+ */
+Enum.setMethod(function getValueConfiguration(value) {
+	return this.getValues()?.get?.(value);
 });

package/lib/app/helper_model/document.js

@@ -1002,7 +1002,7 @@ Document.setMethod(function recomputeFieldIfNecessary(name, force = false) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.21
- * @version  1.3.21
+ * @version  1.4.0
  *
  * @param    {string|Alchemy.Field}   name
  * @param    {*}                      value
@@ -1018,9 +1018,7 @@ Document.setMethod(function _setComputedFieldValue(name, value) {
 	}
 
 	if (Pledge.isThenable(value)) {
-		value.then(value => {
-			this.$main[name] = value;
-		});
+		value = value.then(value => this.$main[name] = value);
 	} else {
 		this.$main[name] = value;
 	}
@@ -1034,7 +1032,7 @@ Document.setMethod(function _setComputedFieldValue(name, value) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.21
- * @version  1.3.21
+ * @version  1.4.0
  *
  * @return   {Pledge|undefined}
  */
@@ -1089,8 +1087,11 @@ Document.setMethod(function recomputeValues() {
 		}
 
 		let result = compute_method.call(this, this, field);
+		result = this._setComputedFieldValue(key, result);
 
-		this._setComputedFieldValue(key, result);
+		if (Pledge.isThenable(result)) {
+			promises.push(result);
+		}
 	}
 
 	if (promises.length) {

package/lib/app/model/system_task_model.js

@@ -15,7 +15,7 @@ const SystemTask = Function.inherits('Alchemy.Model.System', 'Task');
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.17
- * @version  1.3.17
+ * @version  1.4.0
  */
 SystemTask.constitute(function addTaskFields() {
 
@@ -48,9 +48,18 @@ SystemTask.constitute(function addTaskFields() {
 
 	this.addField('schedule_type', 'Enum', {
 		values: {
-			user            : 'User',
-			system_forced   : 'System (forced)',
-			system_fallback : 'System (fallback)',
+			user            : {
+				title : 'User',
+				icon  : 'user',
+			},
+			system_forced   : {
+				title: 'System (forced)',
+				icon : 'shield-keyhole',
+			},
+			system_fallback : {
+				title: 'System (fallback)',
+				icon : 'shield-halved',
+			}
 		},
 		default: 'user',
 	});

package/lib/bootstrap.js

@@ -7,6 +7,11 @@ const libpath = require('path');
  */
 const Protoblast = require('protoblast')(true);
 
+/**
+ * Require Hawkejs next
+ */
+require('hawkejs');
+
 /**
  * Define shared global constants and require methods
  */

package/lib/class/element.js

@@ -7,6 +7,22 @@
  */
 const Element = Function.inherits('Hawkejs.Element', 'Alchemy.Element', 'Element');
 
+/**
+ * Let Alchemy handle the stylesheets of custom elements
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+Classes.Hawkejs.Element.Element.setStylesheetHandler(function handleStylesheet(path) {
+
+	if (!path || Blast.isBrowser) {
+		return;
+	}
+
+	alchemy.registerRequiredStylesheet(path);
+});
+
 /**
  * The default element prefix (when element contains no hyphen) is "al"
  *

package/lib/core/middleware.js

@@ -1,4 +1,4 @@
-var publicDirs = alchemy.shared('public.directories', new Deck()),
+let publicDirs = alchemy.shared('public.directories', new Deck()),
     scriptDirs = alchemy.shared('script.directories', new Deck()),
     assetDirs  = alchemy.shared('asset.directories', new Deck()),
     styleDirs  = alchemy.shared('stylesheet.directories', new Deck()),
@@ -11,9 +11,10 @@ var publicDirs = alchemy.shared('public.directories', new Deck()),
     Nodent     = alchemy.use('nodent-compiler'),
     Terser     = alchemy.use('terser'),
     libpath    = alchemy.use('path'),
+    required_stylesheets = new Set(),
     nodent_compiler,
     regenerator_runtime,
-	sass_functions,
+    sass_functions,
     babel_polyfill,
     babel_preset,
     babel_async,
@@ -122,7 +123,7 @@ function getMiddlePaths(paths, ext, new_ext) {
 }
 
 /**
- * Less middleware
+ * Stylesheet middleware
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
@@ -130,17 +131,11 @@ function getMiddlePaths(paths, ext, new_ext) {
  */
 Alchemy.setMethod(function styleMiddleware(req, res, nextMiddleware) {
 
-	var warnings,
-	    compiled,
-	    o_stats,
-	    path,
-	    url;
-
 	// Get the URL object
-	url = req.conduit.url;
+	let url = req.conduit.url;
 
 	// Get the path, including the query
-	path = url.path;
+	let path = url.path;
 
 	// If this file has already been found & compiled, serve it to the user
 	if (asset_cache.has(path)) {
@@ -151,41 +146,106 @@ Alchemy.setMethod(function styleMiddleware(req, res, nextMiddleware) {
 		}});
 	}
 
-	// Non-critical errors go here
-	warnings = [];
+	let css_path = req.middlePath;
+
+	findStylesheet(css_path, {compile: true}).done((err, result) => {
+
+		if (err) {
+			return req.conduit.error(err);
+		}
+
+		let compiled_path = result?.compiled?.path;
+
+		if (!compiled_path) {
+			return nextMiddleware();
+		}
+
+		return req.conduit.serveFile(compiled_path, {
+			mimetype: 'text/css',
+			onError: function onError(err) {
+				if (fileCache[compiled_path]) {
+					fileCache[compiled_path] = null;
+
+					let source_path = result.source?.path;
+
+					if (stats && fileCache[source_path]) {
+						fileCache[source_path] = null;
+					}
+
+					alchemy.styleMiddleware(req, res, nextMiddleware);
+				}
+			}
+		});
+	});
+});
+
+/**
+ * Find a stylesheet
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   css_path   Relative path to the CSS source file
+ * @param    {Object}   options
+ *
+ * @return   {Pledge<Object>}
+ */
+function findStylesheet(css_path, options) {
+
+	let source_stats,
+	    compiled,
+	    warnings = [];
+
+	if (css_path[0] != '/') {
+		css_path = '/' + css_path;
+	}
+
+	if (!options) {
+		options = {};
+	}
+
+	let do_compile = options.compile === true;
+
+	if (!css_path.endsWith('.css')) {
+		return Pledge.reject(new Error('Not a .css file'));
+	}
+
+	return Function.series(function getCssPath(next) {
 
-	Function.series(function getCssPath(next) {
 		// Look for a regular .css file
-		alchemy.findAssetPath(req.middlePath, styleDirs.getSorted(), function gotAssetPath(err, stats) {
+		alchemy.findAssetPath(css_path, styleDirs.getSorted(), function gotAssetPath(err, stats) {
 
 			if (err || !stats || !stats.path) {
 				return next();
 			}
 
-			compiled = stats;
+			source_stats = compiled = stats;
 			next();
 		});
 	}, function getLessPath(next) {
 
-		var lessPath;
-
-		if (compiled || !less) {
+		if (source_stats || !less) {
 			return next();
 		}
 
-		lessPath = getMiddlePaths(req.middlePath, /\.css$/, '.less');
+		let less_path = getMiddlePaths(css_path, /\.css$/, '.less');
 
 		// Look through all the asset folders for the less style file
-		alchemy.findAssetPath(lessPath, styleDirs.getSorted(), function gotAssetPath(err, stats) {
+		alchemy.findAssetPath(less_path, styleDirs.getSorted(), function gotAssetPath(err, stats) {
 
 			if (err || !stats || !stats.path) {
 				return next();
 			}
 
-			o_stats = stats;
+			source_stats = stats;
+
+			if (!do_compile) {
+				return next();
+			}
 
 			// Compile this less file
-			alchemy.getCompiledLessPath(stats.path, {}, function gotLessPath(err, cssInfo) {
+			alchemy.getCompiledLessPath(stats.path, options, function gotLessPath(err, cssInfo) {
 
 				if (err) {
 					warnings.push(err);
@@ -199,25 +259,27 @@ Alchemy.setMethod(function styleMiddleware(req, res, nextMiddleware) {
 
 	}, function getScssPath(next) {
 
-		var scssPath;
-
-		if (compiled || !sass) {
+		if (source_stats || !sass) {
 			return next();
 		}
 
-		scssPath = getMiddlePaths(req.middlePath, /\.css$/, '.scss');
+		let scss_path = getMiddlePaths(css_path, /\.css$/, '.scss');
 
 		// Look through all the asset folders for the scss style file
-		alchemy.findAssetPath(scssPath, styleDirs.getSorted(), function gotAssetPath(err, stats) {
+		alchemy.findAssetPath(scss_path, styleDirs.getSorted(), function gotAssetPath(err, stats) {
 
 			if (err || !stats || !stats.path) {
 				return next();
 			}
 
-			o_stats = stats;
+			source_stats = stats;
+
+			if (!do_compile) {
+				return next();
+			}
 
 			// Compile this less file
-			alchemy.getCompiledSassPath(stats.path, {}, function gotSassPath(err, cssInfo) {
+			alchemy.getCompiledSassPath(stats.path, options, function gotSassPath(err, cssInfo) {
 
 				if (err) {
 					warnings.push(err);
@@ -232,34 +294,28 @@ Alchemy.setMethod(function styleMiddleware(req, res, nextMiddleware) {
 	}, function done(err) {
 
 		if (err) {
-			return req.conduit.error(err);
+			throw err;
 		}
 
 		// If there are warnings, use the first one
 		if (warnings.length) {
-			return req.conduit.error(warnings[0]);
+			throw warnings[0];
 		}
 
-		if (!compiled || !compiled.path) {
-			return nextMiddleware();
+		if (options?.post_css_only) {
+			return compiled;
 		}
 
-		return req.conduit.serveFile(compiled.path, {
-			mimetype: 'text/css',
-			onError: function onError(err) {
-				if (fileCache[compiled.path]) {
-					fileCache[compiled.path] = null;
-
-					if (o_stats && fileCache[o_stats.path]) {
-						fileCache[o_stats.path] = null;
-					}
+		if (do_compile && (!compiled || !compiled.path)) {
+			return false;
+		}
 
-					alchemy.styleMiddleware(req, res, nextMiddleware);
-				}
-			}
-		});
+		return {
+			compiled : compiled,
+			source   : source_stats,
+		};
 	});
-});
+}
 
 /**
  * Sourcemap middleware:
@@ -807,7 +863,8 @@ Alchemy.setMethod(function findImagePath(image_path, callback) {
  */
 Alchemy.setMethod(function findAssetPath(assetFile, directories, callback) {
 
-	var sub_path,
+	let found_asset_dir,
+	    sub_path,
 	    found,
 	    iter;
 
@@ -888,6 +945,7 @@ Alchemy.setMethod(function findAssetPath(assetFile, directories, callback) {
 				if (err == null && stats.isFile()) {
 					stats.path = path;
 					found = stats;
+					found_asset_dir = dir;
 				}
 
 				nextc();
@@ -910,6 +968,7 @@ Alchemy.setMethod(function findAssetPath(assetFile, directories, callback) {
 					stats.servepath = cpath;
 					stats.path = cpath;
 					found = stats;
+					found_asset_dir = dir;
 				}
 
 				nextc();
@@ -927,6 +986,10 @@ Alchemy.setMethod(function findAssetPath(assetFile, directories, callback) {
 			found = {};
 		}
 
+		if (found_asset_dir) {
+			found.relative_path = libpath.relative(found_asset_dir, found.path);
+		}
+
 		callback(null, found);
 	});
 });
@@ -936,13 +999,19 @@ Alchemy.setMethod(function findAssetPath(assetFile, directories, callback) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.5.0
- * @version  1.0.5
+ * @version  1.4.0
  *
  * @param    {string}     css
+ * @param    {Object}     options
  * @param    {Function}   callback
  */
-function doPostCss(css, callback) {
+function doPostCss(css, options, callback) {
 	postcss([autoprefixer]).process(css, {from: undefined}).then(function gotCssResult(result) {
+
+		if (options?.post_css_only) {
+			return callback(null, result);
+		}
+
 		callback(null, result.css);
 	}).catch(function gotError(err) {
 		callback(err);
@@ -958,14 +1027,16 @@ function doPostCss(css, callback) {
  */
 Alchemy.setMethod(function getCompiledLessPath(lessPath, options, callback) {
 
+	let check_cache = !options?.post_css_only && options?.cache !== false && alchemy.settings.performance.cache;
+
 	// If it has been compiled before, return that
 	// @todo: check timestamps on dev. Not-founds are not cached
-	if (alchemy.settings.performance.cache && fileCache[lessPath]) {
-		return setImmediate(function lessCache(){callback(null, fileCache[lessPath])});
+	if (check_cache && fileCache[lessPath]) {
+		return setImmediate(() => callback(null, fileCache[lessPath]));
 	}
 
 	if (!lessPath || typeof lessPath != 'string') {
-		return setImmediate(function errCb(){callback(new Error('Invalid path given'))});
+		return setImmediate(() => callback(new Error('Invalid path given')));
 	}
 
 	fs.readFile(lessPath, {encoding: 'utf8'}, function gotLessCode(err, source) {
@@ -1005,6 +1076,10 @@ Alchemy.setMethod(function getCompiledLessPath(lessPath, options, callback) {
 			// @todo: add minify options
 			css = cssTree.css;
 
+			if (options.post_css_only) {
+				return doPostCss(css, options, callback);
+			}
+
 			Blast.openTempFile({suffix: '.css'}, function getTempFile(err, info) {
 
 				var cssBuffer;
@@ -1021,7 +1096,7 @@ Alchemy.setMethod(function getCompiledLessPath(lessPath, options, callback) {
 					return callback(new Error('LESS file failed to compile'));
 				}
 
-				doPostCss(css, function gotResult(err, css) {
+				doPostCss(css, options, function gotResult(err, css) {
 
 					if (err) {
 						return callback(err);
@@ -1049,18 +1124,143 @@ Alchemy.setMethod(function getCompiledLessPath(lessPath, options, callback) {
 	});
 });
 
+/**
+ * Create the alchemy.scss content
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+async function createAlchemyScss() {
+
+	let contents = '';
+
+	for (let css_name of required_stylesheets) {
+		if (!css_name.endsWith('.scss') && !css_name.endsWith('.css') && !css_name.endsWith('.less')) {
+			css_name += '.css';
+		}
+
+		let result = await findStylesheet(css_name);
+
+		if (!result?.source?.relative_path) {
+			throw new Error('Could not find ' + css_name);
+		}
+
+		contents += '@use "' + result.source.relative_path + '";\n';
+	}
+
+	return {contents};
+}
+
+/**
+ * Custom SCSS import logic
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   path_to_import      The requested path to import
+ * @param    {string}   current_file_path   The path to the current file
+ */
+async function customScssImporter(path_to_import, current_file_path) {
+
+	// The alchemy.scss file is a special case
+	if (path_to_import === 'alchemy.scss' || path_to_import === 'alchemy') {
+		return createAlchemyScss();
+	}
+
+	// Get the current directory this SCSS file is in
+	let current_dir = libpath.dirname(current_file_path);
+
+	// Get the dirname to import
+	let dir_to_import = libpath.dirname(path_to_import);
+
+	// Get the filename
+	let filename_to_import = libpath.basename(path_to_import);
+
+	// Get all the style dirs
+	let style_dirs = styleDirs.getSorted();
+
+	// Get the source style dir (the one this file is in)
+	let source_style_dir;
+
+	for (let style_dir of style_dirs) {
+		if (current_dir.startsWith(style_dir)) {
+			source_style_dir = style_dir;
+			break;
+		}
+	}
+
+	let include_paths = [
+		current_dir,
+		...style_dirs,
+	];
+
+	// If the dir this file was in is from one of the allowed style dirs,
+	// we have to add possible overrides to the include paths
+	if (source_style_dir) {
+		let extra_path = current_dir.after(source_style_dir);
+
+		if (extra_path.length > 2) {
+			extra_path = libpath.resolve('/', extra_path);
+			let new_path = libpath.join(PATH_APP, 'assets', 'stylesheets', extra_path);
+			include_paths.unshift(new_path);
+		}
+	}
+
+	for (let include_path of include_paths) {
+		let test_path = libpath.join(include_path, path_to_import);
+
+		let file = new Classes.Alchemy.Inode.File(test_path);
+
+		if (await file.exists()) {
+			return {file: test_path};
+		}
+	}
+
+	// Look for files starting with an underscore
+	if (filename_to_import[0] != '_') {
+		let dashed_filename_to_import = '_' + filename_to_import;
+		return customScssImporter(libpath.join(dir_to_import, dashed_filename_to_import), current_file_path);
+	}
+
+	let extension = libpath.extname(filename_to_import);
+
+	// If no extension was given, look for that too
+	if (!extension) {
+		filename_to_import += '.scss';
+		return customScssImporter(libpath.join(dir_to_import, filename_to_import), current_file_path);
+	}
+
+	if (path_to_import.startsWith('/overrides/')) {
+		return {contents: '// Failed to find ' + path_to_import};
+	}
+
+	throw new Error('SCSS file not found');
+};
+
+function logSassWarning(message, options) {
+	console.warn('Sass warning:', message, options);
+}
+
+function logSassDebug(message, options) {
+	console.log('Sass debug:', message, options);
+}
+
 /**
  * Callback with the compiled CSS filepath
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.2.5
+ * @version  1.4.0
  */
 Alchemy.setMethod(function getCompiledSassPath(sassPath, options, callback) {
 
+	let check_cache = !options?.post_css_only && options?.cache !== false && alchemy.settings.performance.cache;
+
 	// If it has been compiled before, return that
 	// @todo: check timestamps on dev. Not-founds are not cached
-	if (alchemy.settings.performance.cache && fileCache[sassPath]) {
+	if (check_cache && fileCache[sassPath]) {
 		return setImmediate(function lessCache(){callback(null, fileCache[sassPath])});
 	}
 
@@ -1079,8 +1279,13 @@ Alchemy.setMethod(function getCompiledSassPath(sassPath, options, callback) {
 		}
 
 		const render_options = {
-			includePaths   : ['.'].concat(styleDirs.getSorted()).concat(libpath.dirname(sassPath)),
+			includePaths   : styleDirs.getSorted(),
 			functions      : sass_functions,
+			importer       : customScssImporter,
+			logger         : {
+				warn  : logSassWarning,
+				debug : logSassDebug,
+			},
 		};
 
 		if (alchemy.settings.debugging.debug) {
@@ -1104,6 +1309,11 @@ Alchemy.setMethod(function getCompiledSassPath(sassPath, options, callback) {
 		});
 
 		function writeToTemp(content) {
+
+			if (options?.post_css_only) {
+				return doPostCss(content, options, callback);
+			}
+
 			Blast.openTempFile({suffix: '.css'}, function getTempFile(err, info) {
 
 				if (err) {
@@ -1118,7 +1328,7 @@ Alchemy.setMethod(function getCompiledSassPath(sassPath, options, callback) {
 					return writeToFile(info, content);
 				}
 
-				doPostCss(content, function gotPostCss(err, css) {
+				doPostCss(content, options, function gotPostCss(err, css) {
 
 					if (err) {
 						return callback(err);
@@ -1147,7 +1357,121 @@ Alchemy.setMethod(function getCompiledSassPath(sassPath, options, callback) {
 					callback(null, file);
 				});
 			});
+		}
+	});
+});
+
+/**
+ * Register a style that should always be included in the output
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   css_path   Could be a path, could be a name
+ */
+Alchemy.setMethod(function registerRequiredStylesheet(css_path) {
+	required_stylesheets.add(css_path);
+});
+
+/**
+ * Extract CSS exports from a PostCSS result object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {Object}   postcss_result
+ */
+function extractPostCSSExports(postcss_result) {
+
+	const icss_import_rx = /^:import\(("[^"]*"|'[^']*'|[^"']+)\)$/;
+	const icss_balanced_quotes = /^("[^"]*"|'[^']*'|[^"']+)$/;
+	const remove_rules = true;
+	const mode = 'auto';
+
+	const getDeclsObject = (rule) => {
+		const object = {};
+	
+		rule.walkDecls((decl) => {
+			const before = decl.raws.before ? decl.raws.before.trim() : "";
+			object[before + decl.prop] = decl.value;
+		});
+	
+		return object;
+	};
+
+	const icss_imports = {};
+	const icss_exports = {};
+
+	function addImports(node, path) {
+		const unquoted = path.replace(/'|"/g, "");
+		icss_imports[unquoted] = Object.assign(
+			icss_imports[unquoted] || {},
+			getDeclsObject(node)
+		);
+
+		if (remove_rules) {
+			node.remove();
+		}
+	}
 
+	function addExports(node) {
+		Object.assign(icss_exports, getDeclsObject(node));
+		if (remove_rules) {
+			node.remove();
+		}
+	}
+
+	postcss_result.root.each((node) => {
+		if (node.type === 'rule' && mode !== 'at-rule') {
+			if (node.selector.slice(0, 7) === ':import') {
+				const matches = icss_import_rx.exec(node.selector);
+
+				if (matches) {
+					addImports(node, matches[1]);
+				}
+			}
+
+			if (node.selector === ':export') {
+				addExports(node);
+			}
+		}
+
+		if (node.type === 'atrule' && mode !== 'rule') {
+			if (node.name === 'icss-import') {
+				const matches = icss_balanced_quotes.exec(node.params);
+
+				if (matches) {
+					addImports(node, matches[1]);
+				}
+			}
+			if (node.name === 'icss-export') {
+				addExports(node);
+			}
 		}
 	});
+
+	return {
+		imports : icss_imports,
+		exports : icss_exports,
+	};
+}
+
+/**
+ * Extract CSS exports from a CSS file path
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   css_path
+ */
+Alchemy.setMethod(async function extractCSSExports(css_path) {
+
+	let result = await findStylesheet(css_path, {post_css_only: true, compile: true});
+
+	result = extractPostCSSExports(result);
+
+	return result?.exports;
 });

package/lib/scripts/create_shared_constants.js

@@ -17,6 +17,21 @@ function DEFINE(name, value) {
 	Object.defineProperty(globalThis, name, {value: value});
 }
 
+/**
+ * Function to define global constants
+ * and have them inside Hawkejs views too
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Function}
+ */
+function DEFINE_CLIENT(name, value) {
+	DEFINE(name, value);
+	Classes.Hawkejs.setGlobal(name, value);
+}
+
 /**
  * Use DEFINE for itself
  *
@@ -37,7 +52,7 @@ DEFINE('DEFINE', DEFINE);
  *
  * @type     {Informer}
  */
-DEFINE('Blast', __Protoblast);
+DEFINE_CLIENT('Blast', __Protoblast);
 
 /**
  * All classes will be collected here
@@ -48,7 +63,7 @@ DEFINE('Blast', __Protoblast);
  *
  * @type     {Object}
  */
-DEFINE('Classes', Blast.Classes);
+DEFINE_CLIENT('Classes', Blast.Classes);
 
 /**
  * Available types
@@ -59,7 +74,7 @@ DEFINE('Classes', Blast.Classes);
  *
  * @type     {Object}
  */
-DEFINE('Types', Blast.Types);
+DEFINE_CLIENT('Types', Blast.Types);
 
 /**
  * The new Local Date/Time classes
@@ -68,9 +83,9 @@ DEFINE('Types', Blast.Types);
  * @since    1.3.20
  * @version  1.3.20
  */
-DEFINE('LocalDateTime', Classes.Develry.LocalDateTime);
-DEFINE('LocalDate', Classes.Develry.LocalDate);
-DEFINE('LocalTime', Classes.Develry.LocalTime);
+DEFINE_CLIENT('LocalDateTime', Classes.Develry.LocalDateTime);
+DEFINE_CLIENT('LocalDate', Classes.Develry.LocalDate);
+DEFINE_CLIENT('LocalTime', Classes.Develry.LocalTime);
 
 /**
  * The new Decimal classes
@@ -79,10 +94,10 @@ DEFINE('LocalTime', Classes.Develry.LocalTime);
  * @since    1.3.20
  * @version  1.3.20
  */
-DEFINE('Decimal', Classes.Develry.Decimal);
-DEFINE('MutableDecimal', Classes.Develry.MutableDecimal);
-DEFINE('FixedDecimal', Classes.Develry.FixedDecimal);
-DEFINE('MutableFixedDecimal', Classes.Develry.MutableFixedDecimal);
+DEFINE_CLIENT('Decimal', Classes.Develry.Decimal);
+DEFINE_CLIENT('MutableDecimal', Classes.Develry.MutableDecimal);
+DEFINE_CLIENT('FixedDecimal', Classes.Develry.FixedDecimal);
+DEFINE_CLIENT('MutableFixedDecimal', Classes.Develry.MutableFixedDecimal);
 
 /**
  * The Trail class:
@@ -92,4 +107,4 @@ DEFINE('MutableFixedDecimal', Classes.Develry.MutableFixedDecimal);
  * @since    1.4.0
  * @version  1.4.0
  */
-DEFINE('Trail', Classes.Develry.Trail);
+DEFINE_CLIENT('Trail', Classes.Develry.Trail);

package/lib/scripts/preload_modules.js

@@ -49,7 +49,6 @@ alchemy.use('less', 'less');
  *
  * @link   https://npmjs.org/package/hawkejs
  */
-alchemy.use('hawkejs', 'hawkejs');
 alchemy.hawkejs = Classes.Hawkejs.Hawkejs.getInstance();
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "alchemymvc",
 	"description": "MVC framework for Node.js",
-	"version": "1.4.0-alpha.2",
+	"version": "1.4.0-alpha.3",
 	"author": "Jelle De Loecker <jelle@elevenways.be>",
 	"keywords": [
 		"alchemy",
@@ -46,8 +46,8 @@
 	"optionalDependencies": {
 		"janeway"          : "~0.4.4",
 		"less"             : "~4.2.0",
-		"sass"             : "~1.68.0",
-		"sass-embedded"    : "~1.67.0",
+		"sass"             : "~1.71.1",
+		"sass-embedded"    : "~1.71.1",
 		"nodent-compiler"  : "~3.2.13",
 		"socket.io-client" : "~4.7.2",
 		"socket.io-msgpack-parser": "~3.0.2"