solarite 0.2.4 → 0.3.1

package/src/unused/InUseMap.js

@@ -0,0 +1,98 @@
+
+
+
+/**
+ * An array that keeps track of how many elements are in-use.
+ * In-use elements are always at the beginning of the array. */
+export class InUseArray extends Array {
+
+	/**
+	 * @type {int} Everything before this number is in-use. */
+	count = 0;
+
+
+	/**
+	 * Get a value and mark it as in-use.
+	 * @param val {undefined|*} Optional.  If set, find this specific value.  Otherwise find any value.
+	 * @return {undefined|*} The value that is now marked as in-use. */
+	use(val=undefined) {
+		if (val) {
+			// If val doesn't exist or is already in-use, return undefined.
+			let index = this.indexOf(val);
+			if (index === -1 || index < this.count)
+				return undefined;
+
+			// Swap the first available with val.
+			this[index] = this[this.count];
+			this[this.count] = val;
+			this.count++;
+			return val;
+		}
+
+		// Try to get last available.
+		else {
+			if (this.count >= this.length)
+				return undefined;
+			let result = this[this.count];
+			this.count++;
+			return result;
+		}
+	}
+
+	free() {
+		this.count = 0;
+	}
+
+	reset() {
+		this.length = 0;
+	}
+}
+
+/**
+ *
+ */
+export class InUseMap {
+
+	/** @type {Object<string, InUseArray>} */
+	data = {};
+
+	// Set a new value for a key
+	add(key, value) {
+		let data = this.data;
+		let array = data[key]
+		if (!array) {
+			array = new InUseArray();
+			data[key] = array;
+		}
+		array.push(value);
+	}
+
+	// Get all values for a key
+	getAll(key) {
+		return this.data[key] || [];
+	}
+
+	// Find a value matching the given key, mark it as inUse, and return it.
+	use(key, val=undefined) {
+		return this.data[key]?.use(val) || undefined
+	}
+
+	// temporary
+	delete(key, val=undefined) {
+		return this.data[key]?.use(val) || undefined
+	}
+
+	freeAll() {
+		for (let key in this.data)
+			this.data[key].free();
+	}
+
+	hasValue(val) {
+		let data = this.data;
+		let names = [];
+		for (let name in data)
+			if (data[name].includes(val))
+				names.push(name)
+		return names;
+	}
+}

package/src/unused/LinkedList.js

@@ -0,0 +1,117 @@
+export default class LinkedList {
+
+	constructor(input) {
+		this.head = null;
+		this.tail = null;
+		this.map = new Map();
+
+		if (Array.isArray(input)) {
+			input.forEach(val => this.push(val));
+		} else if (input instanceof LinkedList) {
+			for (let val of input) {
+				this.push(val);
+			}
+		}
+	}
+
+	push(value) {
+		if (!this.head) {
+			this.head = value;
+			this.tail = value;
+			return;
+		}
+
+		this.map.set(value, { prev: this.tail, next: null });
+		this.map.set(this.tail, { ...this.map.get(this.tail), next: value });
+		this.tail = value;
+	}
+
+	unshift(value) {
+		if (!this.head) {
+			this.push(value);
+			return;
+		}
+
+		this.map.set(value, { prev: null, next: this.head });
+		this.map.set(this.head, { ...this.map.get(this.head), prev: value });
+		this.head = value;
+	}
+
+	shift() {
+		if (!this.head) return;
+
+		const secondNode = this.map.get(this.head).next;
+
+		if (secondNode) {
+			this.map.set(secondNode, { ...this.map.get(secondNode), prev: null });
+		} else {
+			this.tail = null;
+		}
+
+		this.head = secondNode;
+	}
+
+	pop() {
+		if (!this.tail) return;
+
+		const penultimate = this.map.get(this.tail).prev;
+
+		if (penultimate) {
+			this.map.set(penultimate, { ...this.map.get(penultimate), next: null });
+		} else {
+			this.head = null;
+		}
+
+		this.tail = penultimate;
+	}
+
+	*[Symbol.iterator]() {
+		let currentNode = this.head;
+
+		while (currentNode) {
+			yield currentNode;
+			const mapData = this.map.get(currentNode);
+			currentNode = mapData ? mapData.next : null;
+		}
+	}
+
+	slice(start, end) {
+		const newList = new LinkedList();
+		let currentNode = start;
+
+		while (currentNode && currentNode !== end) {
+			newList.push(currentNode);
+			currentNode = this.map.get(currentNode).next;
+		}
+		if (end) {
+			newList.push(end);
+		}
+
+		return newList;
+	}
+
+
+	splice(start, end, newList) {
+		// TODO: assert items in newList aren't already in our list.
+
+		const firstNewNode = newList instanceof LinkedList ? newList.head : newList[0];
+		const lastNewNode = newList instanceof LinkedList ? newList.tail : newList[newList.length - 1];
+
+		if (firstNewNode) {
+			this.map.set(start, { ...this.map.get(start), next: firstNewNode });
+			this.map.set(firstNewNode, { ...this.map.get(firstNewNode), prev: start });
+		}
+
+		const afterEnd = end ? this.map.get(end).next : null;
+		if (lastNewNode) {
+			this.map.set(lastNewNode, { ...this.map.get(lastNewNode), next: afterEnd });
+			if (afterEnd) {
+				this.map.set(afterEnd, { ...this.map.get(afterEnd), prev: lastNewNode });
+			} else {
+				this.tail = lastNewNode;
+			}
+		} else if (afterEnd) {
+			this.map.set(afterEnd, { ...this.map.get(afterEnd), prev: start });
+		}
+	}
+}

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/Misc.js

@@ -0,0 +1,13 @@
+var Misc = {
+	weakMemoize(obj, callback) {
+		let result = weakMemoizeInputs.get(obj);
+		if (!result) {
+			result = callback(obj);
+			weakMemoizeInputs.set(obj, result);
+		}
+		return result;
+	}
+};
+
+
+let weakMemoizeInputs = new WeakMap();

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/TrackedArray.js

@@ -0,0 +1,54 @@
+
+export default class TrackedArray extends Array {
+	constructor(...args) {
+		super(...args);
+		this.ops = [];
+	}
+
+	// Intercepting 'push' as 'insert'
+	push(...items) {
+		const startIdx = this.length;
+		super.push(...items);
+		this.ops.push({ op: 'insert', index: startIdx, values: items });
+		return this.length;
+	}
+
+	// Intercepting 'pop' as 'remove'
+	pop() {
+		const removedIndex = this.length - 1;
+		const removedItem = super.pop();
+		this.ops.push({ op: 'remove', index: removedIndex, length: 1 });
+		return removedItem;
+	}
+
+	// Intercepting 'shift' as 'remove'
+	shift() {
+		const removedItem = super.shift();
+		this.ops.push({ op: 'remove', index: 0, length: 1 });
+		return removedItem;
+	}
+
+	// Intercepting 'unshift' as 'insert'
+	unshift(...items) {
+		super.unshift(...items);
+		this.ops.push({ op: 'insert', index: 0, values: items });
+		return this.length;
+	}
+
+	// Intercepting 'splice' for insert, update, or remove
+	splice(start, deleteCount, ...items) {
+		const removedItems = super.splice(start, deleteCount, ...items);
+
+		if (deleteCount > 0) {
+			this.ops.push({ op: 'remove', index: start, length: deleteCount });
+		}
+		if (items.length > 0) {
+			const operation = deleteCount > 0 ? 'update' : 'insert';
+			this.ops.push({ op, index: start, values: items });
+		}
+
+		return removedItems;
+	}
+
+	// TODO: reverse, sorty, copyWithin, fill
+}