alchemymvc 1.2.8 → 1.3.1

package/lib/class/sitemap.js

@@ -0,0 +1,341 @@
+let cached_sitemap;
+
+/**
+ * Sitemap class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ */
+const Sitemap = Function.inherits('Alchemy.Base', function Sitemap() {
+	this.categories = {};
+});
+
+/**
+ * Get the sitemap
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Pledge}
+ */
+Sitemap.setStatic(function get() {
+
+	if (cached_sitemap) {
+		return cached_sitemap;
+	}
+
+	let pledge = new Pledge();
+	let sitemap = new Sitemap();
+	cached_sitemap = pledge;
+
+	let loading = sitemap.load();
+
+	Pledge.done(loading, err => {
+
+		if (err) {
+			pledge.reject(err);
+		} else {
+			pledge.resolve(sitemap);
+		}
+	});
+
+	return cached_sitemap;
+});
+
+/**
+ * Get all the categories
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Object}
+ */
+Sitemap.setMethod(function getCategories(prefix) {
+
+	let result = [],
+	    category,
+	    new_category,
+	    entry,
+	    name;
+
+	for (name in this.categories) {
+		category = this.categories[name];
+		new_category = [];
+
+		for (entry of category) {
+
+			if (entry.prefix && prefix && entry.prefix != prefix) {
+				continue;
+			}
+
+			new_category.push(entry);
+		}
+
+		if (new_category.length) {
+			result.push({
+				name  : name,
+				pages : new_category,
+			});
+		}
+	}
+
+	return result;
+});
+
+/**
+ * Start loading the contents
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Pledge}
+ */
+Sitemap.setMethod(function load() {
+
+	let sections = Router.getFullRoutes(),
+	    promises = [],
+	    key;
+	
+	for (key in sections) {
+		let promise = this.processSection(sections[key]);
+		promises.push(promise);
+	}
+
+	return Function.parallel(promises);
+});
+
+/**
+ * Add a URL to the sitemap
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+Sitemap.setMethod(function addUrl(category, url, config = {}, prefix = '') {
+
+	if (!this.categories[category]) {
+		this.categories[category] = [];
+	}
+
+	this.categories[category].push({
+		url          : url,
+		title        : config.title,
+		changefreq   : config.changefreq,
+		priority     : config.priority,
+		lastmod      : config.lastmod,
+		prefix       : prefix,
+	});
+});
+
+/**
+ * Process a route section
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setMethod(function processSection(section) {
+
+	let promise,
+	    tasks = [],
+	    route,
+	    key;
+
+	for (key in section) {
+		route = section[key];
+
+		if (!route.sitemap) {
+			continue;
+		}
+
+		promise = this.processRoute(route, route.sitemap);
+
+		if (promise) {
+			tasks.push(promise);
+		}
+	}
+
+	return Function.parallel(tasks);
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route], function processRoute(route) {
+
+	if (!route.sitemap) {
+		return;
+	}
+
+	return this.processRoute(route, route.sitemap);
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route, Types.Boolean], function processRoute(route, value) {
+
+	if (!value) {
+		return;
+	}
+
+	return this.processRoute(route, {category: 'general'});
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route, Types.Object], function processRoute(route, config) {
+
+	const category = config.category;
+
+	if (!category) {
+		return;
+	}
+
+	let criteria = config.criteria;
+
+	if (criteria) {
+
+		if (typeof criteria == 'function') {
+
+			let prefixes = [];
+
+			for (let prefix in route.paths) {
+				if (prefix) {
+					prefixes.push(prefix);
+				}
+			}
+
+			if (prefixes.length) {
+				let tasks = [];
+
+				for (let prefix of prefixes) {
+					let prefixed_criteria = criteria(prefix);
+					let task = this.processRouteCriteria(route, config, prefixed_criteria);
+
+					if (task) {
+						tasks.push(task);
+					}
+				}
+
+				return Function.parallel(tasks);
+			}
+
+			criteria = criteria();
+		}
+
+		return this.processRouteCriteria(route, config, criteria);
+	}
+
+	return this.addRouteWithParameters(route, config);
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route, Types.Object, Types.Alchemy.Criteria], async function processRouteCriteria(route, config, criteria) {
+
+	let prefix = criteria.options.locale;
+
+	for await (const record of criteria) {
+		this.addRouteWithParameters(route, config, record, prefix);
+	}
+});
+
+/**
+ * Add a route with the given parameters
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setMethod(function addRouteWithParameters(route, config, parameters, forced_prefix) {
+
+	if (!parameters) {
+		parameters = {};
+	} else {
+		parameters = Object.create(parameters);
+	}
+
+	let route_parameters = Object.assign(parameters, config.parameters),
+	    prefixes = [];
+	
+	if (forced_prefix) {
+		prefixes.push(forced_prefix);
+	} else {
+		for (let prefix in route.paths) {
+			prefixes.push(prefix);
+		}
+	}
+
+	for (let prefix of prefixes) {
+
+		if (!route.paths[prefix]) {
+			continue;
+		}
+
+		let url = Router.getUrl(route.name, route_parameters, {
+			absolute             : true,
+			locale               : prefix,
+			extra_get_parameters : false,
+		});
+
+		let route_config = Object.assign({}, config);
+
+		if (parameters && parameters.getDisplayFieldValue) {
+			route_config.title = parameters.getDisplayFieldValue({prefix});
+		}
+
+		if (!route_config.title) {
+			if (route.title) {
+				if (typeof route.title == 'object' && !(route.title instanceof Classes.Alchemy.Microcopy)) {
+					route_config.title = route.title[prefix] || route.title[''];
+				} else {
+					route_config.title = route.title;
+				}
+			}
+		}
+
+		if (!route_config.title) {
+			route_config.title = route.name;
+		}
+
+		this.addUrl(config.category, url, route_config, prefix);
+	}
+});

package/lib/core/base.js

@@ -233,9 +233,9 @@ Base.setStatic(function getAllChildren() {
 /**
  * Find a member of this group
  *
- * @author   Jelle De Loecker <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.3.0
- * @version  1.1.4
+ * @version  1.3.0
  */
 Base.setStatic(function getMember(name) {
 
@@ -243,6 +243,10 @@ Base.setStatic(function getMember(name) {
 		throw new Error('Unable to get class member of ' + this.name + ', given name is empty');
 	}
 
+	if (name.includes('.')) {
+		return this.getDescendant(name);
+	}
+
 	if (this.group == null) {
 		return null;
 	}
@@ -713,4 +717,10 @@ Base.setMethod(function debugMark(message) {
  */
 alchemy.getClassGroup = __Protoblast.getGroup;
 
-// PROTOBLAST END CUT
+// PROTOBLAST END CUT
+
+// @TODO: put this somewhere else
+if (Blast.isBrowser) {
+	window.Types = Blast.Types;
+	window.Classes = Blast.Classes;
+}

package/lib/core/client_alchemy.js

@@ -5,7 +5,7 @@
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.1.0
- * @version  1.0.5
+ * @version  1.3.0
  */
 var Alchemy = Function.inherits('Alchemy.Client.Base', function Alchemy() {
 
@@ -22,6 +22,8 @@ var Alchemy = Function.inherits('Alchemy.Client.Base', function Alchemy() {
 
 	// Sent subscriptions
 	this.sent_subscriptions = [];
+
+	this.distinct_problems = new Map();
 });
 
 /**
@@ -125,6 +127,75 @@ Alchemy.setMethod(function initScene(scene, options) {
 	});
 });
 
+
+/**
+ * Log a distinct warning
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.1
+ *
+ * @param    {String}   id
+ * @param    {String}   message
+ * @param    {Object}   options
+ *
+ * @return   {Object}
+ */
+Alchemy.setMethod(function distinctProblem(id, message, options = {}) {
+
+	if (!id) {
+		return;
+	}
+
+	let do_log = true,
+	    entry = this.distinct_problems.get(id),
+	    now = Date.now();
+
+	if (!entry) {
+		entry = {
+			id,
+			last_seen    : 0,
+			last_logged  : 0,
+			counter      : 0,
+			repeat_after : options.repeat_after || 0,
+		};
+
+		this.distinct_problems.set(id, entry);
+	} else {
+		if (entry.repeat_after) {
+			let wait_until = entry.last_logged + entry.repeat_after;
+
+			if (now >= wait_until) {
+				do_log = true;
+			} else {
+				do_log = false;
+			}
+		} else {
+			do_log = false;
+		}
+	}
+
+	if (do_log) {
+		let args = ['[Distinct]', id];
+
+		if (message) {
+			args.push(message);
+		}
+
+		if (options.error) {
+			args.push(options.error);
+		}
+
+		this.printLog(options.level || 'error', args, options);
+		entry.last_logged = now;
+	}
+
+	entry.counter++;
+	entry.last_seen = now;
+
+	return entry;
+});
+
 /**
  * Actually print a log message
  *
@@ -511,7 +582,7 @@ Alchemy.setMethod(function linkup(type, data, cb) {
  *
  * @author    Jelle De Loecker   <jelle@develry.be>
  * @since     0.3.0
- * @version   1.2.5
+ * @version   1.3.0
  *
  * @param     {Object}   variables
  * @param     {Object}   render_data
@@ -542,7 +613,7 @@ Alchemy.setMethod(function markLinks(variables, render_data) {
 	elements = document.querySelectorAll('[data-alchemy-language-switch]');
 
 	for (i = 0; i < elements.length; i++) {
-		hawkejs.scene.general_renderer.helpers.Router.updateLanguageSwitcher(elements[i]);
+		hawkejs.scene.general_renderer.helpers.Router.updateLanguageSwitcher(elements[i], variables);
 	}
 
 	// Get all the elements with a breadcrumb set
@@ -835,17 +906,17 @@ Alchemy.decorateMethod(Blast.Decorators.memoize({max_age: 500, ignore_callbacks:
 /**
  * Get a route
  *
- * @author    Jelle De Loecker   <jelle@develry.be>
+ * @author    Jelle De Loecker   <jelle@elevenways.be>
  * @since     1.1.0
- * @version   1.1.0
+ * @version   1.3.0
  *
  * @param     {String}   href         The href or route name
  * @param     {Object}   parameters   Route parameters
  *
  * @return    {String}
  */
-Alchemy.setMethod(function routeUrl(href, parameters) {
-	let temp = hawkejs.scene.helpers.Router.routeUrl(href, parameters);
+Alchemy.setMethod(function routeUrl(href, parameters, options) {
+	let temp = hawkejs.scene.helpers.Router.routeUrl(href, parameters, options);
 
 	if (temp) {
 		temp = String(temp);

package/lib/core/client_base.js

@@ -294,19 +294,22 @@ ClientBase.setMethod(function getModel(name, init, options) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.1
- * @version  1.1.1
+ * @version  1.3.0
  *
  * @param    {String}   name   The name of the event to emit
  * @param    {Array}    args   The parameters to pass to the event
  * @param    {Function} next   The optional callback
+ *
+ * @return   {Pledge}
  */
 ClientBase.setMethod(function issueEvent(name, args, next) {
 
 	let that = this,
 	    method_name,
-	    promise;
+	    promise,
+	    pledge = new Pledge();
 
-	if (typeof args == 'function') {
+	if (typeof args == 'function' || !Array.isArray(args)) {
 		next = args;
 		args = [];
 	}
@@ -326,20 +329,23 @@ ClientBase.setMethod(function issueEvent(name, args, next) {
 	Pledge.done(promise, function doneEventPromise(err, result) {
 
 		if (err) {
+			pledge.reject(err);
 			return next(err);
 		}
 
-		if (result === false) {
-			return;
-		}
+		if (result !== false) {
+			let event_args = args.slice(0);
 
-		let event_args = args.slice(0);
+			event_args.unshift(name);
+			event_args.push(next);
 
-		event_args.unshift(name);
-		event_args.push(next);
+			that.emit.apply(that, event_args);
+		}
 
-		that.emit.apply(that, event_args);
+		pledge.resolve(result);
 	});
+
+	return pledge;
 });
 
 if (!Blast.isBrowser) {