solarite 0.3.0 → 0.3.2

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
+}

package/src/unused/WeakArray.js

@@ -0,0 +1,33 @@
+export default class WeakArray {
+	constructor() {
+		this.items = [];
+	}
+
+	push(...items) {
+		for (let item of items) {
+			if (typeof item === 'object' && item)
+				this.items.push(new WeakRef(item));
+			else
+				throw new TypeError("Only objects can be added to a WeakArray");
+		}
+	}
+
+	get(index) {
+		const ref = this.items[index];
+		if (ref)
+			return ref.deref();
+		return undefined;
+	}
+
+	cleanup() {
+		this.items = this.items.filter(ref => ref.deref() !== undefined);
+	}
+
+	*[Symbol.iterator]() {
+		for (const ref of this.items) {
+			const value = ref.deref();
+			if (value !== undefined)
+				yield value;
+		}
+	}
+}

package/src/{solarite/watch.js → watch.js}

@@ -51,8 +51,8 @@ a.items.push({name: 'Fred'});
 */
 
 import Globals from "./Globals.js";
-import Util from "../util/Util.js";
-import {assert} from "../util/Errors.js";
+import Util from "./Util.js";
+import {assert} from "./assert.js";
 
 let unusedArg = Symbol('unusedArg');
 
@@ -210,7 +210,7 @@ export function renderWatched(root, trackModified=false) {
  * Handles getting and setting properties on the proxied object. */
 class ProxyHandler {
 
-	/** @type {Object<string, [Proxy, ProxyHandler]>} Proxies for child properties. */
+	/** @type {Record<string, [Proxy, ProxyHandler]>} Proxies for child properties. */
 	proxies = {}
 
 	/** @type Set<ExprPath> ExprPaths that will need to be re-rendered when this variable is modified. */
@@ -219,7 +219,7 @@ class ProxyHandler {
 	/**
 	 * ExprPaths that will need to be re-rendered when one of this variable's primitive properties is modified,
 	 * since primitives can't have their own ProxyHandler.
-	 * @type {Object<prop:string, affected:Set<ExprPath>>} */
+	 * @type {Record<prop:string, affected:Set<ExprPath>>} */
 	childExprPaths = {};
 
 

package/src/util/Util.js

@@ -1,101 +0,0 @@
-
-
- 
- /**
- * @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;
-	},
-
-	/**
-	 * Use an array as the value of a map, appending to it when we add.
-	 * Used by watch.js.
-	 * @param map {Map|WeakMap|Object}
-	 * @param key
-	 * @param value */
-	mapArrayAdd(map, key, value) {
-		let result = map.get(key);
-		if (!result) {
-			result = [value];
-			map.set(key, result);
-		}
-		else
-			result.push(value);
-	},
-};
-
-
-export default Util;