solarite 0.1.0

package/src/unused/LinkedList.test.js

@@ -0,0 +1,115 @@
+import Testimony, {assert} from "../../tests/Testimony.js";
+import LinkedList from "./LinkedList.js";
+
+Testimony.test('LinkedList.constructor with Array input', () => {
+	const linkedList = new LinkedList(['A', 'B', 'C']);
+	assert.eq([...linkedList], ['A', 'B', 'C']);
+});
+
+Testimony.test('LinkedList.constructor with LinkedList input', () => {
+	const originalList = new LinkedList(['X', 'Y', 'Z']);
+	const copiedList = new LinkedList(originalList);
+	assert.eq([...copiedList], ['X', 'Y', 'Z']);
+});
+
+Testimony.test('LinkedList.constructor with mixed input', () => {
+	const originalList = new LinkedList(['D', 'E']);
+	const extendedList = new LinkedList([...originalList, 'F', 'G']);
+	assert.eq([...extendedList], ['D', 'E', 'F', 'G']);
+});
+
+Testimony.test('LinkedList.constructor with no input', () => {
+	const emptyList = new LinkedList();
+	assert.eq([...emptyList], []);
+});
+
+
+Testimony.test('LinkedList.push', () => {
+	const linkedList = new LinkedList();
+	linkedList.push("A");
+	linkedList.push("B");
+	assert.eq([...linkedList], ['A', 'B']);
+});
+
+Testimony.test('LinkedList.unshift', () => {
+	const linkedList = new LinkedList();
+	linkedList.unshift("B");
+	linkedList.unshift("A");
+	assert.eq([...linkedList], ['A', 'B']);
+});
+
+Testimony.test('LinkedList.shift', () => {
+	const linkedList = new LinkedList();
+	linkedList.push("A");
+	linkedList.push("B");
+	linkedList.shift();
+	assert.eq([...linkedList], ['B']);
+	linkedList.shift();
+	assert.eq([...linkedList], []);
+});
+
+Testimony.test('LinkedList.pop', () => {
+	const linkedList = new LinkedList();
+	linkedList.push("A");
+	linkedList.push("B");
+	linkedList.pop();
+	assert.eq([...linkedList], ['A']);
+	linkedList.pop();
+	assert.eq([...linkedList], []);
+});
+
+Testimony.test('LinkedList.slice', () => {
+	const linkedList = new LinkedList();
+	linkedList.push("A");
+	linkedList.push("B");
+	linkedList.push("C");
+	const subList = linkedList.slice("A", "B");
+	assert.eq([...subList], ['A', 'B']);
+});
+
+Testimony.test('LinkedList._splice', () => {
+	const linkedList = new LinkedList();
+	linkedList.push("A");
+	linkedList.push("B");
+	linkedList.splice("A", null, ["X", "Y"]);
+	assert.eq([...linkedList], ['A', 'X', 'Y', 'B']);
+	linkedList.splice("X", "Y");
+	assert.eq([...linkedList], ['B']);
+});
+
+
+
+
+function buildData(count = rowCount) {
+	function _random(max) {
+		return Math.round(Math.random()*1000)%max;
+	}
+
+	var adjectives = ["pretty", "large", "big", "small", "tall", "short", "long", "handsome", "plain", "quaint", "clean", "elegant", "easy", "angry", "crazy", "helpful", "mushy", "odd", "unsightly", "adorable", "important", "inexpensive", "cheap", "expensive", "fancy"];
+	var colours = ["red", "yellow", "blue", "green", "pink", "brown", "purple", "brown", "white", "black", "orange"];
+	var nouns = ["table", "chair", "house", "bbq", "desk", "car", "pony", "cookie", "sandwich", "burger", "pizza", "mouse", "keyboard"];
+	var data = [];
+	for (let i=0; i<count; i++)
+		data.push({id: i, label: adjectives[_random(adjectives.length)] + " " + colours[_random(colours.length)] + " " + nouns[_random(nouns.length)] });
+	return data;
+}
+
+
+Testimony.test('LinkedList.benchmark', () => {
+
+	let data = buildData(10_000)
+	let start = performance.now()
+	let list = new LinkedList(data);
+	console.log(performance.now() - start)
+
+	start = performance.now()
+	let i = 0;
+	for (let item in list) {
+		i++;
+	}
+	console.log(i)
+	console.log(performance.now() - start)
+
+
+
+});

package/src/unused/Perf.js

@@ -0,0 +1,47 @@
+var Perf = {
+	_timers: {},
+
+	/**
+	 * Start a timer with a given name.
+	 * @param timerName {string}
+	 */
+	start(timerName) {
+		if (!Perf._timers[timerName]) {
+			Perf._timers[timerName] = {
+				startTime: null,
+				elapsedTime: 0
+			};
+		}
+		Perf._timers[timerName].startTime = performance.now();
+	},
+
+	/**
+	 * Stop a timer with a given name and calculate the elapsed time.
+	 * @param timerName {string}
+	 */
+	stop(timerName) {
+		if (Perf._timers[timerName] && Perf._timers[timerName].startTime !== null) {
+			let stopTime = performance.now();
+			Perf._timers[timerName].elapsedTime += stopTime - Perf._timers[timerName].startTime;
+			Perf._timers[timerName].startTime = null;  // Reset start time
+		}
+	},
+
+	/**
+	 * Get the total time elapsed for each timer.
+	 * @return {string[]}
+	 */
+	getReport() {
+		let report = [];
+		for (let timerName in Perf._timers) {
+			report.push(`${timerName}: ${Perf._timers[timerName].elapsedTime.toFixed(2)} ms`);
+		}
+		return report;
+	},
+
+	clear() {
+		this._timers = {};
+	}
+}
+
+export default Perf;

package/src/unused/Template.js

@@ -0,0 +1,108 @@
+import getObjectId from "./getObjectId.js";
+
+import {memoize, hashObject, hashObject64, hash64Cache, hashObjectJson, getObjectId3} from "./Util.js";
+
+let htmlMap = new WeakMap();
+
+/**
+ * version of the template class that still has the old memoize function, If I ever want to compare hashing speed again.
+ */
+export default class Template {
+
+	/** @type {string[]} Html strings.  Stored externally from object to speed up JSON serialization. */
+	//get html() { return htmlMap.get(this) }
+
+
+	/** @type {(Template|string|function)|(Template|string|function)[]} Evaulated expressions.  */
+	exprs = []
+
+	html = [];
+
+	hashedFields;
+
+	/**
+	 *
+	 * @param htmlStrings {string}
+	 * @param exprs {*[]} */
+	constructor(htmlStrings, exprs) {
+		//htmlMap.set(this, htmlStrings)
+		this.html = htmlStrings;
+		this.exprs = exprs;
+
+		this.hashedFields = [getObjectId(htmlStrings), exprs]
+
+		//#IFDEV
+		Object.defineProperty(this, 'debug', {
+			get() {
+				return this.memoize();
+			}
+		})
+		//#ENDIF
+	}
+
+	/**
+	 * Called by JSON.serialize when it encounters a Template.
+	 * This prevents the hashed version from being too large.
+	 * @returns {*}
+	 */
+	toJSON() {
+		return this.hashedFields
+	}
+
+	memoize() {
+
+		// Slower
+		// let result2 = hashObject64(this)
+		// return result2[0].toString(16) + result2[1].toString(16);
+
+		// This version is slower but includes the full html in the template and can help with debugging:
+		//#IFDEV
+		// let exprLength = this.exprs.length;
+		// let l = this.html.length + exprLength;
+		// let result = new Array(l);
+		// for (let i=0; i<exprLength; i++) {
+		// 	result[i*2] = this.html[i];
+		// 	result[i*2+1] = '${' + s(this.exprs[i]) + '}'
+		// }
+		// result[result.length-1] = this.html[this.html.length-1];
+		//
+		// return result.join('')
+		//#ENDIF
+
+		// Speed up most common case:
+		if (this.exprs.length === 1)
+			return memoizeValue(this.exprs[0]) + '\f' + this.htmlId // \f is the "Form feed" control character, unlikely to be usedin regular text.
+
+		let exprLength = this.exprs.length;
+		let result = new Array(exprLength+1);
+		let exprs = this.exprs;
+		for (let i=0; i<exprLength; i++) {
+			result[i] = memoizeValue(exprs[i])
+		}
+		result[result.length] = this.htmlId;
+
+		return result.join('\f')
+	}
+
+	getCloseKey() {
+		// Use the joined html when debugging?
+		//return '@'+this.html.join('|')
+
+		return '@'+this.hashedFields[0];
+	}
+}
+
+
+
+
+function memoizeValue(val) {
+	if (typeof val === 'string')
+		return val;
+	else if (Array.isArray(val))
+		return '[' + val.map(v => memoizeValue(v)) + `]`; // join(',') is implicitly called here.
+	else if (val && val.memoize) // is another Template
+		return 'T('+val.memoize()+')'
+	else
+		return memoize(val); // TODO: This might not differentiate between 1 and '1'
+
+}

package/src/util/Errors.js

@@ -0,0 +1,9 @@
+//#IFDEV
+/*@__NO_SIDE_EFFECTS__*/
+export function assert(val) {
+	if (!val) {
+		debugger;
+		throw new Error('Assertion failed: ' + val);
+	}
+}
+//#ENDIF

package/src/util/Util.js

@@ -0,0 +1,88 @@
+
+
+ 
+ /**
+ * @typedef {Array|function(...*)} Callbacks
+ * @property {function(function)} push
+ * @property {function()} remove
+ * @property {function()} pause
+ * @property {function()} resume
+ * */
+
+
+/**
+ * A place for functions that have no other home. */
+var Util = {
+
+	/**
+	 * Create an array-like object that stores a group of callbacks.
+	 * Supports all array functions and properties like push() and .length.
+	 * Can be called directly.
+	 *
+	 * @param functions {function[]}
+	 * @return {Callbacks|function}
+	 *
+	 * @example
+	 * var c = Util.callback();
+	 * var f = () => console.log(3);
+	 * c.push(f);
+	 * c();
+	 * c.remove(f);
+	 * c();
+	 */
+	callback(...functions) {
+		var paused = false;
+
+		// Make it callable.  When we call it, call all callbacks() with the given args.
+		let result = async function(...args) {
+			let result2 = [];
+			if (!paused)
+				for (let i=0; i<result.length; i++)
+					result2.push(result[i](...args));
+			return await Promise.all(result2);
+		};
+		
+		// Make it iterable.
+		result[Symbol.iterator] = function() {
+			let index = 0;
+			return {
+				next: () => index < result.length
+					 ? {value: result[index++], done: false}
+					 : {done: true}
+			};
+		};
+
+		// Use properties from Array
+		for (let prop of Object.getOwnPropertyNames(Array.prototype))
+			if (prop !== 'length' && prop !== 'constructor')
+				result[prop] = Array.prototype[prop];
+
+		result.l = 0; // Internal length
+		Object.defineProperty(result, 'length', {
+			get() { return result.l },
+			set(val) { result.l = val}
+		});
+
+		// Add the remove() function.
+		result.remove = func => {
+			let idx = result.findIndex(item => item === func);
+			if (idx !== -1)
+				result.splice(idx, 1);
+		};
+		result.pause = () => paused = true;
+
+		result.resume = () => paused = false;
+
+		// Add initial functions
+		for (let f of functions)
+			result.push(f);
+
+		return result;
+	},
+	
+
+
+};
+
+
+export default Util;

package/src/util/delve.js

@@ -0,0 +1,43 @@
+/**
+ * Follow a path into an object.
+ * @param obj {object}
+ * @param path {string[]}
+ * @param createVal {*}  If set, non-existant paths will be created and value at path will be set to createVal.
+ * @return {*} The value, or undefined if it can't be reached. */
+export default function delve(obj, path, createVal = delveDontCreate) {
+	let isCreate = createVal !== delveDontCreate;
+
+	let len = path.length;
+	if (!obj && !isCreate && len)
+		return undefined;
+
+	let i = 0;
+	for (let srcProp of path) {
+
+		// If the path is undefined and we're not to the end yet:
+		if (obj[srcProp] === undefined) {
+
+			// If the next index is an integer or integer string.
+			if (isCreate) {
+				if (i < len - 1) {
+					// If next level path is a number, create as an array
+					let isArray = (path[i + 1] + '').match(/^\d+$/);
+					obj[srcProp] = isArray ? [] : {};
+				}
+			} else
+				return undefined; // can't traverse
+		}
+
+		// If last item in path
+		if (isCreate && i === len - 1)
+			obj[srcProp] = createVal;
+
+		// Traverse deeper along destination object.
+		obj = obj[srcProp];
+		i++;
+	}
+
+	return obj;
+}
+
+let delveDontCreate = {};