solarite 0.2.4 → 0.3.1

package/src/Globals.js

@@ -0,0 +1,79 @@
+var Globals;
+
+/**
+ * Created with a reset() function because it's useful for testing. */
+function reset() {
+	Globals = {
+
+		/**
+		 * Used by NodeGroup.applyComponentExprs() */
+		componentArgsHash: new WeakMap(),
+
+		/**
+		 * Store which instances of Solarite have already been added to the DOM.
+		 * @type {WeakSet<HTMLElement>} */
+		connected: new WeakSet(),
+
+		/**
+		 * ExprPath.applyExactNodes() sets this property when an expression is being accessed.
+		 * watch() then adds the ExprPath to the list of ExprPaths that should be re-rendered when the value changes.
+		 * @type {ExprPath}*/
+		currentExprPath: null,
+
+		div: document.createElement("div"),
+
+		/**
+		 * @type {Record<string, Class<Node>>} A map from built-in tag names to the constructors that create them. */
+		elementClasses: {},
+
+		/** @type {Record<string, boolean>} Key is tag-name.propName.  Value is whether it's an attribute.*/
+		htmlProps: {},
+
+		/**
+		 * Used by ExprPath.applyEventAttrib()
+		 * @type {WeakMap<Node, Record<eventName:string, [original:function, bound:function, args:*[]]>>} */
+		nodeEvents: new WeakMap(),
+
+		/**
+		 * Get the RootNodeGroup for an element.
+		 * @type {WeakMap<HTMLElement, RootNodeGroup>} */
+		nodeGroups: new WeakMap(),
+
+		/**
+		 * Used by r() path 9. */
+		objToEl: new WeakMap(),
+
+		//pendingChildren: [],
+
+
+		/**
+		 * Elements that have been rendered to by r() at least once.
+		 * This is used by the Solarite class to know when to call onFirstConnect()
+		 * @type {WeakSet<HTMLElement>} */
+		rendered: new WeakSet(),
+
+		/**
+		 * Elements that are currently rendering via the r() function.
+		 * @type {WeakSet<HTMLElement>} */
+		rendering: new WeakSet(),
+
+		/**
+		 * Map from array of Html strings to a Shell created from them.
+		 * @type {WeakMap<string[], Shell>} */
+		shells: new WeakMap(),
+
+		/**
+		 * A map of individual untagged strings to their Templates.
+		 * This way we don't keep creating new Templates for the same string when re-rendering.
+		 * This is used by ExprPath.applyExactNodes()
+		 * @type {Record<string, Template>} */
+		//stringTemplates: {},
+
+		reset,
+
+		count: 0
+	};
+}
+reset();
+
+export default Globals;

package/src/HtmlParser.js

@@ -0,0 +1,91 @@
+
+export default class HtmlParser {
+	constructor() {
+		this.defaultState = {
+			context: HtmlParser.Text, // possible values: 'TEXT', 'TAG', 'ATTRIBUTE'
+			quote: null, // possible values: null, '"', "'"
+			buffer: '',
+			lastChar: null
+		};
+		this.state = {...this.defaultState};
+	}
+
+	reset() {
+		this.state = {...this.defaultState};
+		return this.state.context;
+	}
+
+	/**
+	 * Parse the next chunk of html, starting with the same context we left off with from the previous chunk.
+	 * @param html {string}
+	 * @param onContextChange {?function(html:string, index:int, oldContext:string, newContext:string)}
+	 *     Called every time the context changes, and again at the last context.
+	 * @return {('Attribute','Text','Tag')} The context at the end of html.  */
+	parse(html, onContextChange=null) {
+		if (html === null)
+			return this.reset();
+
+		for (let i = 0; i < html.length; i++) {
+			const char = html[i];
+			switch (this.state.context) {
+				case HtmlParser.Text:
+					if (char === '<' && html[i + 1].match(/[/a-z!]/i)) { // Start of a tag or comment.
+						onContextChange?.(html, i, this.state.context, HtmlParser.Tag);
+						this.state.context = HtmlParser.Tag;
+						this.state.buffer = '';
+					}
+					break;
+				case HtmlParser.Tag:
+					if (char === '>') {
+						onContextChange?.(html, i+1, this.state.context, HtmlParser.Text);
+						this.state.context = HtmlParser.Text;
+						this.state.quote = null;
+						this.state.buffer = '';
+					}
+					else if (char === ' ' && !this.state.buffer) {
+						// No attribute name is present. Skipping the space.
+						continue;
+					}
+					else if (char === ' ' || char === '/' || char === '?') {
+						this.state.buffer = ''; // Reset the buffer when a delimiter or potential self-closing sign is found.
+					}
+					else if (char === '"' || char === "'" || char === '=') {
+						onContextChange?.(html, i, this.state.context, HtmlParser.Attribute);
+						this.state.context = HtmlParser.Attribute;
+						this.state.quote = char === '=' ? null : char;
+						this.state.buffer = '';
+					}
+					else
+						this.state.buffer += char;
+					break;
+				case HtmlParser.Attribute:
+					// Start an attribute quote.
+					if (!this.state.quote && !this.state.buffer.length && (char === '"' || char === "'")) {
+						this.state.quote = char;
+					}
+					else if (char === this.state.quote || (!this.state.quote && this.state.buffer.length)) {
+						onContextChange?.(html, i, this.state.context, HtmlParser.Tag);
+						this.state.context = HtmlParser.Tag;
+						this.state.quote = null;
+						this.state.buffer = '';
+					}
+					else if (!this.state.quote && char === '>') {
+						onContextChange?.(html, i+1, this.state.context, HtmlParser.Text);
+						this.state.context = HtmlParser.Text;
+						this.state.quote = null;
+						this.state.buffer = '';
+					}
+					else if (char !== ' ')
+						this.state.buffer += char;
+
+					break;
+			}
+		}
+		onContextChange?.(html, html.length, this.state.context, null);
+		return this.state.context;
+	}
+}
+
+HtmlParser.Attribute = 'Attribute';
+HtmlParser.Text = 'Text';
+HtmlParser.Tag = 'Tag';

package/src/{util/MultiValueMap.js → MultiValueMap.js}

@@ -1,6 +1,6 @@
 export default class MultiValueMap {
 
-	/** @type {Object<string, Set>} */
+	/** @type {Record<string, Set>} */
 	data = {};
 
 	// Set a new value for a key
@@ -34,23 +34,14 @@ export default class MultiValueMap {
 	 * @param val If specified, make sure we delete this specific value, if a key exists more than once.
 	 * @returns {*|undefined} The deleted item. */
 	delete(key, val=undefined) {
-		// if (key === '["Html2",[[["Html3",["F1","A"]],["Html3",["F1","B"]]]]]')
-		// 	debugger;
-
 		let data = this.data;
-
-		// if (!data.hasOwnProperty(key))
-		// 	return undefined;
-
-		// Delete a specific value.
 		let result;
 		let set = data[key];
-		if (!set) // slower than pre-check.
+		if (!set)
 			return undefined;
 
 		// Delete any value.
 		if (val === undefined) {
-			//result = set.values().next().value; // get first item from set.
 			[result] = set; // Does the same as above and seems to be about the same speed.
 			set.delete(result);
 		}
@@ -61,7 +52,6 @@ export default class MultiValueMap {
 			result = val;
 		}
 
-		// TODO: Will this make it slower?
 		if (set.size === 0)
 			delete data[key];
 
@@ -69,28 +59,34 @@ export default class MultiValueMap {
 	}
 
 	/**
-	 * Try to delete an item that matches the key and the isPreferred function.
-	 * if not the latter, just delete any item that matches the key.
+	 * Remove one value from a key, and return it.
 	 * @param key {string}
-	 * @param isPreferred {function}
 	 * @returns {*|undefined} The deleted item. */
-	deletePreferred(key, isPreferred) {
+	deleteAny(key) {
+		let data = this.data;
 		let result;
+		let set = data[key];
+		if (!set) // slower than pre-check.
+			return undefined;
+
+		[result] = set; // Does the same as above and seems to be about the same speed.
+		set.delete(result);
+
+		if (set.size === 0)
+			delete data[key];
+
+		return result;
+	}
+
+	deleteSpecific(key, val) {
 		let data = this.data;
+		let result;
 		let set = data[key];
 		if (!set)
 			return undefined;
 
-		for (let val of set)
-			if (isPreferred(val)) {
-				set.delete(val);
-				result = val;
-				break;
-			}
-		if (!result) {
-			[result] = set;
-			set.delete(result);
-		}
+		set.delete(val);
+		result = val;
 
 		if (set.size === 0)
 			delete data[key];