alchemymvc 1.3.6 → 1.3.8

package/lib/app/helper/alchemy_helper.js

@@ -290,16 +290,18 @@ Alchemy.setMethod(function group(name, id, callback) {
 /**
  * Print a segment
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.5.0
- * @version  1.1.5
+ * @version  1.3.7
  *
  * @param    {String|Object}   options
  * @param    {Object}          data
+ *
+ * @return   {HePlaceholder}
  */
 Alchemy.setMethod(function segment(options, data) {
 
-	var that = this;
+	const that = this;
 
 	if (typeof options == 'string') {
 		options = {
@@ -307,10 +309,14 @@ Alchemy.setMethod(function segment(options, data) {
 		};
 	}
 
-	let start = Date.now();
+	let print_placeholder = options.print;
+
+	if (print_placeholder == null) {
+		print_placeholder = true;
+	}
 
 	// Prints a placeholder
-	this.view.async(function doAsync(next) {
+	return this.view.async(function doAsync(next) {
 
 		var conduit,
 		    route;
@@ -354,7 +360,7 @@ Alchemy.setMethod(function segment(options, data) {
 
 			next(null, block);
 		});
-	});
+	}, {print: print_placeholder});
 });
 
 /**

package/lib/app/helper/breadcrumb.js

@@ -0,0 +1,156 @@
+/**
+ * The Breadcrumb class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @param    {String}   input
+ */
+const Breadcrumb = Function.inherits('Alchemy.Base', function Breadcrumb(input) {
+
+	this.trails = [];
+	
+	if (input) {
+		this.addTrail(input);
+	}
+});
+
+/**
+ * Get the number of trails
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @return   {Number}
+ */
+Breadcrumb.setProperty(function length() {
+	return this.trails.length;
+});
+
+/**
+ * Add a breadcrumb trail
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @param    {String}   input
+ */
+Breadcrumb.setMethod(function addTrail(input) {
+
+	let trails;
+
+	if (!input) {
+		input = '';
+	} else if (typeof input == 'object') {
+		if (input instanceof Breadcrumb) {
+			trails = input.trails;
+		} else if (input.nodeType === 1) {
+			// Simple way to see if it's an HTMLElement
+
+			let element = input;
+			input = '';
+
+			let crumb = element.getAttribute('data-breadcrumb');
+
+			if (crumb) {
+				input = crumb;
+			}
+
+			crumb = element.getAttribute('data-breadcrumbs');
+
+			if (crumb) {
+				input += ' ' + crumb;
+			}
+		}
+	}
+
+	if (!trails) {
+		// Split the string why whitespaces
+		trails = input.trim().split(/\s+|\|+/);
+	}
+
+	if (trails?.length) {
+		for (let trail of trails) {
+
+			if (!trail) {
+				continue;
+			}
+
+			// The trail has to end with a dot
+			if (!trail.endsWith('.')) {
+				trail += '.';
+			}
+
+			this.trails.push(trail);
+		}
+	}
+});
+
+/**
+ * Do these 2 breadcrumbs match loosely?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @param    {Alchemy.Breadcrumb}   other
+ */
+Breadcrumb.setMethod(function matches(other) {
+	return this.matchLevel(other) > 0;
+});
+
+/**
+ * What leven of match is there between these 2 breadcrumbs?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @param    {Alchemy.Breadcrumb}   other
+ *
+ * @return   {Number}   1 for a strict match, 2 for a loose match
+ */
+Breadcrumb.setMethod(function matchLevel(other) {
+
+	if (!other || !this.trails.length) {
+		return 0;
+	}
+
+	if (!(other instanceof Breadcrumb)) {
+		other = new Breadcrumb(other);
+	}
+
+	let their_trail,
+	    our_trail;
+	
+	for (our_trail of this.trails) {
+		for (their_trail of other.trails) {
+			// Strict matches are always true
+			if (our_trail == their_trail) {
+				return 1;
+			}
+
+			if (our_trail.startsWith(their_trail)) {
+				return 2;
+			}
+		}
+	}
+
+	return 0;
+});
+
+/**
+ * Turn it into a string
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ */
+Breadcrumb.setMethod(function toString() {
+	return this.trails.join(' ');
+});

package/lib/app/helper/router_helper.js

@@ -147,14 +147,24 @@ Router.setMethod(function applyDirective(element, name, options) {
 		}
 	}
 
-	if (config.breadcrumb) {
-		let link_breadcrumb = this.getTrail(name, params);
+	let breadcrumb = config.breadcrumb;
+
+	if (options.breadcrumb) {
+		if (!breadcrumb) {
+			breadcrumb = options.breadcrumb;
+		} else {
+			breadcrumb += ' ' + options.breadcrumb;
+		}
+	}
+
+	if (config.breadcrumb || options.breadcrumb) {
+		let link_breadcrumb = this.getTrail(name, {...params}, options);
 		element.setAttribute('data-breadcrumb', link_breadcrumb);
 
 		if (this.renderer && link_breadcrumb) {
-			let page_breadcrumb = this.renderer.internal('breadcrumb');
+			let page_breadcrumb = new Classes.Alchemy.Breadcrumb(this.renderer.internal('breadcrumb'));
 
-			if (page_breadcrumb && page_breadcrumb.startsWith(link_breadcrumb)) {
+			if (page_breadcrumb.matches(link_breadcrumb)) {
 
 				if (element.parentElement) {
 					// @TODO: We need to make sure the options (classnames & such)
@@ -223,7 +233,7 @@ Router.setMethod(function applyDirective(element, name, options) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.6
+ * @version  1.3.7
  *
  * @param    {String}   name
  * @param    {Boolean}  socket_route   Look in the socket routes
@@ -288,22 +298,17 @@ Router.setMethod(function routeConfig(name, socket_route) {
 	if (routes[section] != null && routes[section][name] != null) {
 		let route = routes[section][name];
 
-		let result = {
-			section : section,
-			name    : name
-		};
+		let result;
 
 		if (socket_route) {
-			result.socket_route = true;
+			result = {
+				section      : section,
+				name         : name,
+				socket_route : true,
+			};
 		} else {
+			result = Object.create(route);
 			result.socket_route = false;
-			result.paths = route.paths;
-			result.breadcrumb = route.breadcrumb;
-			result.has_breadcrumb_assignments = route.has_breadcrumb_assignments;
-			result.keys = route.keys;
-			result.methods = route.methods;
-			result.permission = route.permission;
-			result.has_permission_assignments = route.has_permission_assignments;
 		}
 
 		let router_options;
@@ -329,9 +334,9 @@ Router.setMethod(function routeConfig(name, socket_route) {
 /**
  * Return the plain url for the given url name & parameters object
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.0
+ * @version  1.3.7
  *
  * @param    {String}   name
  * @param    {Object}   parameters
@@ -392,6 +397,33 @@ Router.setMethod(function routeUrl(name, parameters, options) {
 			return '#url_config_' + name + '_notfound';
 		}
 
+		if (config.param_definitions) {
+
+			let documents = {},
+			    definition,
+			    key;
+
+			for (key in config.param_definitions) {
+				definition = config.param_definitions[key];
+
+				// If this definition has a specific model name,
+				// try to get it from the parameters (and also remove it from there)
+				if (definition.type_class_name) {
+					if (!documents[definition.type_class_name]) {
+						documents[definition.type_class_name] = parameters[definition.type_class_name];
+
+						if (documents[definition.type_class_name]) {
+							delete parameters[definition.type_class_name];
+						}
+					}
+				}
+
+				if (!parameters[definition.name] && documents[definition.type_class_name]) {
+					parameters[definition.name] = documents[definition.type_class_name][definition.type_field_name];
+				}
+			}
+		}
+
 		// Remove [brackets]
 		url = url.replace(/\[.*?\]/g, '');
 		url = url.assign(parameters, true, RURL.encodeUriQuery);
@@ -470,28 +502,72 @@ Router.setMethod(function routeUrl(name, parameters, options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.3.0
- * @version  0.3.0
+ * @version  1.3.8
  *
  * @param    {String}   name
  * @param    {Object}   parameters
+ * @param    {Object}   options
  *
- * @return   {String}
+ * @return   {Alchemy.Breadcrumb}
  */
-Router.setMethod(function getTrail(name, parameters) {
+Router.setMethod(function getTrail(name, parameters, options) {
 
-	var breadcrumb,
+	let can_have_assignments,
+	    trails = [],
 	    config;
+	
+	if (options?.breadcrumb) {
+		can_have_assignments = true;
+		trails.push(options.breadcrumb);
+	}
 
 	config = this.routeConfig(name);
 
-	if (!config || !config.breadcrumb) {
+	if (!trails.length && (!config || !config.breadcrumb)) {
 		return;
 	}
 
-	breadcrumb = config.breadcrumb;
+	let breadcrumb = new Classes.Alchemy.Breadcrumb();
+
+	if (config?.breadcrumb) {
+		trails.push(config.breadcrumb);
+	}
 
-	if (config.has_breadcrumb_assignments) {
-		breadcrumb = Blast.Bound.String.assign(breadcrumb, parameters).toLowerCase();
+	if (!can_have_assignments) {
+		can_have_assignments = config?.has_breadcrumb_assignments;
+	}
+
+	if (can_have_assignments) {
+		let key;
+		parameters = {...parameters};
+
+		for (key in parameters) {
+			if (key[0] == key[0].toUpperCase()) {
+				let value = parameters[key];
+
+				if (value && typeof value == 'object') {
+					let subkey;
+
+					let context = value?.$main || value;
+
+					for (subkey in context) {
+						if (parameters[subkey] == null) {
+							parameters[subkey] = context[subkey];
+						}
+					}
+				}
+			}
+		}
+	}
+
+	let trail;
+
+	for (trail of trails) {
+		if (can_have_assignments) {
+			trail = Blast.Bound.String.assign(trail, parameters).toLowerCase();
+		}
+
+		breadcrumb.addTrail(trail);
 	}
 
 	return breadcrumb;
@@ -505,9 +581,6 @@ Router.setMethod(function getTrail(name, parameters) {
  * @version  0.3.0
  */
 Router.setMethod(function printBreadcrumb() {
-
-	var that = this;
-
 	this.view.print_partial('breadcrumb/wrapper');
 });
 
@@ -717,7 +790,7 @@ Router.setMethod(function updateLanguageSwitcher(element, variables) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.2.5
- * @version  1.3.0
+ * @version  1.3.8
  *
  * @param    {String}   prefix    The prefix to use
  * @param    {Object}   variables
@@ -739,6 +812,15 @@ Router.setMethod(function translateCurrentRoute(prefix, variables) {
 		return;
 	}
 
+	// Don't just translate the last rendered route, make sure it's the current one
+	if (info.url && Blast.isBrowser) {
+		let url = RURL.parse(info.url);
+
+		if (url && !url.matchesPath(window.location)) {
+			return;
+		}
+	}
+
 	let config = this.routeConfig(info.route);
 
 	if (!config) {
@@ -762,6 +844,8 @@ Router.setMethod(function translateCurrentRoute(prefix, variables) {
 
 	// Add the get queries
 	if (info.url && info.url.search) {
+		let key;
+
 		for (key in info.url.query) {
 
 			if (key == 'hajax' || key == 'h_diversion' || key == 'htop') {

package/lib/app/helper_field/boolean_field.js

@@ -33,4 +33,24 @@ BooleanField.setDatatype('boolean');
  */
 BooleanField.setMethod(function cast(value) {
 	return Boolean(value);
-});
+});
+
+/**
+ * See if the given vlaue is considered not-empty for this field
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.7
+ * @version  1.3.7
+ *
+ * @param    {Mixed}   value
+ *
+ * @return   {Boolean}
+ */
+BooleanField.setMethod(function valueHasContent(value) {
+
+	if (value === undefined) {
+		return false;
+	}
+
+	return true;
+});

package/lib/app/helper_field/schema_field.js

@@ -89,13 +89,11 @@ SchemaField.setProperty(function requires_translating() {
 /**
  * Get the subschema of this field
  *
- * @constructor
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.1
+ * @version  1.3.7
  *
- * @param    {Object}   record
+ * @param    {Object}   record      This *should* be the schema context (might not be the root)
  * @param    {String}   some_path   Some path to a field in the wanted schema
  *
  * @return   {Schema}

package/lib/app/helper_model/model.js

@@ -597,9 +597,9 @@ Model.setMethod(function getAliasModel(alias) {
 /**
  * Query the database
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.3.4
+ * @version  1.3.8
  *
  * @param    {String}     type       The type of find (first, all)
  * @param    {Criteria}   criteria   The criteria object
@@ -660,7 +660,7 @@ Model.setMethod(function find(type, criteria, callback) {
 	}
 
 	if (!criteria.options.locale && this.conduit) {
-		criteria.setOption('locale', this.conduit.prefix);
+		criteria.setOption('locale', this.conduit.active_prefix);
 	}
 
 	let that = this,

package/lib/class/field.js

@@ -1078,6 +1078,36 @@ Field.setMethod(function getRules() {
 	return result;
 });
 
+/**
+ * See if the given vlaue is considered not-empty for this field
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.7
+ * @version  1.3.7
+ *
+ * @param    {Mixed}   value
+ *
+ * @return   {Boolean}
+ */
+Field.setMethod(function valueHasContent(value) {
+
+	if (value == null) {
+		return false;
+	}
+
+	if (value === '') {
+		return false;
+	}
+
+	if (Array.isArray(value)) {
+		if (value.length === 0) {
+			return false;
+		}
+	}
+
+	return true;
+});
+
 /**
  * Translate the given value
  *

package/lib/class/model.js

@@ -310,7 +310,7 @@ Model.prepareProperty('datasource', function datasource() {
  * @type {Object}
  */
 Model.prepareProperty('sort', function sort() {
-	return {created: 1};
+	return {[this.primary_key]: -1};
 });
 
 /**

package/lib/class/path_param_definition.js

@@ -5,7 +5,7 @@ const PathDefinition = Classes.Alchemy.PathDefinition;
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.3.0
- * @version  1.3.0
+ * @version  1.3.7
  */
 const PathParamDefinition = Function.inherits('Alchemy.Base', function PathParamDefinition(config) {
 
@@ -41,6 +41,9 @@ const PathParamDefinition = Function.inherits('Alchemy.Base', function PathParam
 	// The optional type class constructor
 	this.type_class_constructor = null;
 
+	// Is this a model type?
+	this.is_model_type = false;
+
 	// Has all the config been parsed?
 	this.is_parsed = false;
 });
@@ -79,6 +82,30 @@ PathParamDefinition.setStatic(function from(input) {
 	return new this(input);
 });
 
+/**
+ * Get the model constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.7
+ * @version  1.3.7
+ */
+PathParamDefinition.enforceProperty(function model_constructor(new_value) {
+
+	if (!this.is_parsed) {
+		this.parseTypeDefinition();
+	}
+
+	if (!new_value) {
+		const constructor = this.type_class_constructor;
+
+		if (constructor && this.is_model_type) {
+			new_value = constructor;
+		}
+	}
+
+	return new_value;
+});
+
 /**
  * Parse the type definition
  *
@@ -131,7 +158,14 @@ PathParamDefinition.setMethod(function parseTypeDefinition() {
 		this.type_field_name = field_name;
 
 		const Model = Classes.Alchemy.Model || Classes.Alchemy.Client.Model;
-		this.type_class_constructor = Object.path(Model, class_name) || Object.path(Classes.Alchemy, class_name) || Object.path(Classes, class_name);
+
+		this.type_class_constructor = Object.path(Model, class_name);
+
+		if (this.type_class_constructor) {
+			this.is_model_type = true;
+		} else {
+			this.type_class_constructor = Object.path(Classes.Alchemy, class_name) || Object.path(Classes, class_name);
+		}
 	}
 });
 

package/lib/class/route.js

@@ -129,6 +129,116 @@ Route.setProperty(function has_type_class_checks() {
 	return result;
 });
 
+/**
+ * Routes with parameters can have schemas
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.7
+ * @version  1.3.7
+ *
+ * @return   {Schema}
+ */
+Route.enforceProperty(function schema(new_value) {
+
+	if (new_value) {
+		return new_value;
+	}
+
+	if (!this.has_path_assignments) {
+		return false;
+	}
+
+	let added_models = {},
+	    added_fields = {},
+	    prefix,
+	    param,
+	    model_constructor,
+	    definition;
+
+	new_value = alchemy.createSchema();
+	
+	for (prefix in this.paths) {
+		definition = this.paths[prefix];
+
+		if (!definition?.param_definitions?.length) {
+			continue;
+		}
+
+		for (param of definition.param_definitions) {
+			model_constructor = param.model_constructor;
+
+			if (model_constructor) {
+
+				if (added_models[model_constructor.name]) {
+					continue;
+				}
+
+				if (added_fields[param.name]) {
+					continue;
+				}
+
+				added_models[model_constructor.name] = true;
+
+				try {
+					new_value.belongsTo(model_constructor.name);
+				} catch (err) {
+					// Ignored
+					alchemy.distinctProblem('route-schema-' + this.name, 'Route schema error', {error: err});
+				}
+			} else {
+				new_value.addField(param.name, 'String');
+				added_fields[param.name] = true;
+			}
+		}
+	}
+
+	return new_value;
+});
+
+/**
+ * Get all the param definitions
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.7
+ * @version  1.3.7
+ *
+ * @return   {Object}
+ */
+Route.enforceProperty(function param_definitions(new_value) {
+
+	if (new_value) {
+		return new_value;
+	}
+
+	let prefix,
+	    param,
+	    key,
+	    definition;
+
+	new_value = {};
+
+	for (prefix in this.paths) {
+		definition = this.paths[prefix];
+
+		if (!definition.param_definitions?.length) {
+			continue;
+		}
+
+		for (param of definition.param_definitions) {
+			key = prefix + '_' + param.name;
+
+			new_value[key] = {
+				name            : param.name,
+				type_class_name : param.type_class_name,
+				type_field_name : param.type_field_name,
+				is_model_type   : param.is_model_type,
+			};
+		}
+	}
+
+	return new_value;
+});
+
 /**
  * Set the breadcrumb for this route
  *

package/lib/class/router.js

@@ -1163,7 +1163,7 @@ RouterClass.setMethod(function getOptions(result) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.0
+ * @version  1.3.7
  *
  * @param    {Object}   result   Optional object to store sectioned results in
  *
@@ -1212,6 +1212,8 @@ RouterClass.setMethod(function getRoutes(result) {
 			has_permission_assignments : route.has_permission_assignments || undefined,
 			title                      : route.title,
 			visible_location           : route.visible_location,
+			schema                     : route.schema,
+			param_definitions          : route.param_definitions,
 		};
 	}
 

package/lib/core/client_alchemy.js

@@ -519,6 +519,59 @@ Alchemy.setMethod(function routeConfig(name) {
 
 const markLinkElement = Alchemy.prototype.markLinkElement;
 
+/**
+ * Get a live map of all the routes
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @return   {Develry.BackedMap}
+ */
+Alchemy.setMethod(function getRoutes() {
+	return new Classes.Develry.BackedMap(getRoutesDict);
+});
+
+/**
+ * The live-map dictionary creator
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.8
+ * @version  1.3.8
+ *
+ * @return   {Object}
+ */
+function getRoutesDict() {
+	let routes;
+
+	if (Blast.isNode) {
+		routes = {};
+
+		let roots = Router.getRoutes();
+
+		for (let key in roots) {
+			let root = roots[key];
+
+			for (let name in root) {
+				routes[name] = root[name];
+			}
+		}
+		
+	} else {
+		routes = {};
+
+		for (let root in hawkejs.scene.exposed.routes) {
+			let section = hawkejs.scene.exposed.routes[root];
+
+			for (let key in section) {
+				routes[key] = section[key];
+			}
+		}
+	}
+
+	return routes;
+}
+
 // From here on, only client-side code is added
 if (Blast.isBrowser) {
 	window.alchemy = new Alchemy();
@@ -582,21 +635,18 @@ Alchemy.setMethod(function linkup(type, data, cb) {
  *
  * @author    Jelle De Loecker   <jelle@develry.be>
  * @since     0.3.0
- * @version   1.3.0
+ * @version   1.3.8
  *
  * @param     {Object}   variables
  * @param     {Object}   render_data
  */
 Alchemy.setMethod(function markLinks(variables, render_data) {
 
-	var page_breadcrumb,
-	    el_breadcrumbs,
-	    el_breadcrumb,
+	let page_breadcrumb,
 	    placeholder,
 	    href_val,
 	    elements,
 	    element,
-	    temp,
 	    url,
 	    i;
 
@@ -607,7 +657,7 @@ Alchemy.setMethod(function markLinks(variables, render_data) {
 	}
 
 	// Get the newly set breadcrumb
-	page_breadcrumb = variables.__breadcrumb;
+	page_breadcrumb = new Classes.Alchemy.Breadcrumb(variables.__breadcrumb);
 
 	// Get all the language switcher anchors
 	elements = document.querySelectorAll('[data-alchemy-language-switch]');
@@ -621,30 +671,7 @@ Alchemy.setMethod(function markLinks(variables, render_data) {
 
 	for (i = 0; i < elements.length; i++) {
 		element = elements[i];
-
-		// Create the breadcrumbs array
-		el_breadcrumbs = [];
-
-		// Get the element's set breadcrumb
-		el_breadcrumb = element.getAttribute('data-breadcrumb');
-
-		if (el_breadcrumb) {
-			el_breadcrumbs.push(el_breadcrumb);
-		}
-
-		el_breadcrumb = element.getAttribute('data-breadcrumbs');
-
-		if (el_breadcrumb) {
-			el_breadcrumbs.include(el_breadcrumb.split('|'));
-		}
-
-		if (el_breadcrumbs.indexOf(page_breadcrumb) > -1) {
-			markLinkElement(element, 1);
-		} else if (page_breadcrumb && page_breadcrumb.startsWithAny(el_breadcrumbs)) {
-			markLinkElement(element, 2);
-		} else {
-			markLinkElement(element, false);
-		}
+		markLinkElement(element, page_breadcrumb.matchLevel(element));
 	}
 
 	// Get all anchors without breadcrumbs
@@ -702,9 +729,9 @@ Alchemy.setMethod(function markLinks(variables, render_data) {
 /**
  * Reload all stylesheets
  *
- * @author    Jelle De Loecker   <jelle@develry.be>
+ * @author    Jelle De Loecker   <jelle@elevenways.be>
  * @since     1.0.0
- * @version   1.2.5
+ * @version   1.3.8
  */
 Alchemy.setMethod(function reloadStylesheets() {
 
@@ -718,15 +745,15 @@ Alchemy.setMethod(function reloadStylesheets() {
 		let url = new RURL(sheet.href);
 		url.param('last_reload', Date.now());
 
-		//sheet.ownerNode.href = String(url);
-
 		let new_element = alchemy.hawkejs.createElement('link');
 		new_element.setAttribute('rel', 'stylesheet');
 		new_element.setAttribute('href', String(url));
 		document.head.append(new_element);
 
 		new_element.addEventListener('load', e => {
-			sheet.ownerNode.remove();
+			if (sheet.ownerNode) {
+				sheet.ownerNode.remove();
+			}
 		});
 	}
 });

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "alchemymvc",
 	"description": "MVC framework for Node.js",
-	"version": "1.3.6",
+	"version": "1.3.8",
 	"author": "Jelle De Loecker <jelle@elevenways.be>",
 	"keywords": [
 		"alchemy",